1 寫在前面

JVM + 核心類庫 = JRE + 編譯器等開發(fā)工具 = JDK

Java環(huán)境變量的配置 : 計算機(jī) -> 屬性-> 高級系統(tǒng)設(shè)置 -> 系統(tǒng)變量 -> 新建系統(tǒng)變量

JAVA_HOME : 選擇Java工具包的bin目錄的上一級目錄

Path : %JAVA_HOME%bin

Java程序開發(fā)三步驟 : 編寫, 編譯, 運行

編譯 : javac.exe 編譯器 運行 : java.exe 解釋器

public class HelloWorld {public static void main(String[] args) {System.out.println("Hello World!");} }// 先 javac HelloWorld.java, 再 java HelloWorld

2 標(biāo)識符的概念及規(guī)則

• 標(biāo)識符 : 在程序中,我們自己定義的內(nèi)容; 比如類, 方法, 變量的 名字 都稱為標(biāo)識符
• 命名規(guī)則 : 硬性要求
  • 標(biāo)識符可以包含英文字母26個(區(qū)分大小寫),0-9數(shù)字,$(美元符號) 和 _(下劃線)
  • 標(biāo)識符不能以數(shù)字開頭
  • 標(biāo)識符不能是已有的關(guān)鍵字

• 命名規(guī)范 : 軟性建議
  • 類名規(guī)范 : 首字母大寫, 后面每個單詞首字母大寫 (大駝峰式)
  • 變量名規(guī)范 : 首字母小寫, 后面每個單詞首字母大寫 (小駝峰式)
  • 方法名規(guī)范 : 同變量名規(guī)范

3 常量

定義 : 是指在Java程序運行期間固定不變的數(shù)據(jù)

| 類型 | 含義 | 數(shù)據(jù)舉例 | | ---------- | ---------------------------------------- | ---------------- | | 整數(shù)常量 | 所有的整數(shù) | 0, 1 , 5, -5 | | 浮點數(shù)常量 | 所有的小數(shù) | 1.4 , 0.0, -4.9 | | 字符常量 | 單引號引起來的,只能寫一個字符,必須有內(nèi)容 | 'a', ‘好’ | | 字符串常量 | 雙引號引起來的,可以寫多個, 可以不寫 | 'aaaaa', 'Hello’ | | 布爾常量 | 兩個值 | true, fasle | | 空常量 | 一個值; 空常量不能直接用來打印輸出 | null |

System.out.println(5); System.out.println(5.0); System.out.println('5'); System.out.println("admin);

4 數(shù)據(jù)基本類型

Java數(shù)據(jù)類型分為兩大類 : 基本數(shù)據(jù)類型 和 引用數(shù)據(jù)類型

基本數(shù)據(jù)類型 : 整數(shù), 浮點數(shù), 字符, 布爾這四大類 又可分為八種

引用數(shù)據(jù)類型 : 字符串, 類, 數(shù)組, 接口, Lambda

| 數(shù)據(jù)類型 | 關(guān)鍵字 | 內(nèi)存占用 | 取值范圍 | | ------------ | ------- | ------------- | ------------------------ | | 字節(jié)型 | byte | 1個字節(jié) | -128 ~127 | | 短整型 | short | 2 個字節(jié) | -32768 ~ 32767 | | 整型 | int | 4個字節(jié)(默認(rèn)) | -2的31次方 ~ 2的31次方-1 | | 長整型 | long | 8個字節(jié) | -2的63次方 ~ 2的63次方-1 | | 單精度浮點數(shù) | float | 4個字節(jié) | 1.4013E-45 ~ 3.4028E+38 | | 雙精度浮點數(shù) | double | 8個字節(jié) | 4.9E-324~1.7977E+308 | | 字符 | char | 2個字節(jié) | 0-65535 | | 布爾 | boolean | 1個字節(jié) | true, false |

注意事項 :

字符串不是基本類型, 而是引用類型

浮點型可能是一個近似值, 并非精確的值

數(shù)據(jù)范圍與字節(jié)數(shù)不一定相關(guān), 例如float數(shù)據(jù)范圍比long更加廣泛,但是float是4個字節(jié),long是8個字節(jié)

浮點數(shù)當(dāng)中默認(rèn)類型是double,如果一定要使用float類型, 需要加上一個后綴F, 推薦使用大寫字母后綴

如果是整數(shù), 默認(rèn)是int類型, 如果一定要使用long類型, 需要加上一個后綴F, 推薦使用大寫字母后綴

5 變量

定義 : 在程序運行期間可以變化的量稱為變量

Java中要求一個變量每次只能保存一個數(shù)據(jù), 且必須要明確保存變量的數(shù)據(jù)類型

變量定義的格式包括三個要素： 數(shù)據(jù)類型 、 變量名 、 數(shù)據(jù)值 。

數(shù)據(jù)類型 變量名稱 = 數(shù)據(jù)值; // 創(chuàng)建了一個變量,并將數(shù)據(jù)值賦值給變量

注意事項 :

如果創(chuàng)建多個變量, 變量之間的名稱不可以重復(fù)

對于float和long類型來說, 字母后綴F和L不要丟掉

如果使用byte或者short類型的變量, 那么右側(cè)的數(shù)據(jù)值不能超過左側(cè)類型的范圍

沒有進(jìn)行賦值的變量, 不能直接使用; 一定要賦值之后, 才能使用

變量的使用不能超過作用域的范圍[作用域: 從定義變量的一行開始, 一直到直接所屬的大括號為止]

6 數(shù)據(jù)類型轉(zhuǎn)換

自動類型轉(zhuǎn)化 -- 隱式轉(zhuǎn)換

將取值小的范圍自動提升為取值范圍大的類型, 比如:一個int類型與byte字節(jié)類型相加運算是int類型

public static void main(String[] args){int i = 1;byte b = 2;// byte x = b + i; // 報錯 // int類型和byte類型運算，結(jié)果是int類型 int j = b + i; System.out.println(j); }

同樣道理當(dāng)一個 int 類型變量和一個double 變量運算時，int 類型將會自動提升為 double 類型進(jìn)行運算。

public static void main(String[] args) {int i = 1; double d = 2.5; //int類型和double類型運算，結(jié)果是double類型 // int類型會提升為double類型double e = d+i;System.out.println(e);}

轉(zhuǎn)換規(guī)則 :范圍小的類型向 范圍大的類型提升; byte, short ,char 運算時直接提升為 int

byte、short、char‐‐>int‐‐>long‐‐>float‐‐>double

強(qiáng)制類型轉(zhuǎn)換 -- 顯式轉(zhuǎn)換

將 1.5 賦值到 int 類型變量會發(fā)生什么? 產(chǎn)生編譯失敗, 肯定無法賦值

int i = 1.5 // // 錯誤 double 類型內(nèi)存8個字節(jié)， int 類型內(nèi)存4個字節(jié)。 1.5 是 double 類型，取值范圍大于 int ?？梢岳斫鉃?double 是8 升的水壺， int 是4升的水壺，不能把大水壺中的水直接放進(jìn)小水壺去。 想要賦值成功，只有通過強(qiáng)制類型轉(zhuǎn)換，將 double 類型強(qiáng)制轉(zhuǎn)換成 int 類型才能賦值。

強(qiáng)制類型轉(zhuǎn)換：將取值范圍大的類型 強(qiáng)制轉(zhuǎn)換成 取值范圍小的類型 。 比較而言，自動轉(zhuǎn)換是Java自動執(zhí)行的，而強(qiáng)制轉(zhuǎn)換需要我們自己手動執(zhí)行。

轉(zhuǎn)換格式 : 數(shù)據(jù)類型 (范圍小) 變量名 (范圍小) = (數(shù)據(jù)類型 -- 范圍小) 被轉(zhuǎn)數(shù)據(jù)值(范圍大);

int i = (int) 1.5;public static void main(String[] args) { //short類型變量，內(nèi)存中2個字節(jié) short s = 1;/*出現(xiàn)編譯失敗 s和1做運算的時候，1是int類型，s會被提升為int類型 s+1后的結(jié)果是int類型，將結(jié)果在賦值會short類型時發(fā)生錯誤 short內(nèi)存2個字節(jié)，int類型4個字節(jié) 必須將int強(qiáng)制轉(zhuǎn)成short才能完成賦值 */s = s + 1;//編譯失敗 s = (short) (s+1);//編譯成功 }

注意事項 :

強(qiáng)制類型轉(zhuǎn)換一般不推薦使用, 有可能發(fā)生精度損失, 數(shù)據(jù)溢出

7 ASCII編碼表

public static void main(String[] args){// 字符類型變量char c = 'a';int i = 1;// 字符類型和int類型計算System.out.println(c+i); //輸出結(jié)果為98 }

| 字符 | 數(shù)值 | | :--- | :--- | | 0 | 48 | | 9 | 57 | | A | 65 | | Z | 90 | | a | 97 | | z | 122 |

在char類型和int類型計算的過程中，char類型的字符先查詢編碼表，得到97，再和1求和，結(jié)果為98。 char類型提升 為了int類型。char類型內(nèi)存2個字節(jié)，int類型內(nèi)存4個字節(jié)。

8 運算符

算數(shù)運算符

| 算數(shù)運算符包括： | | | :--------------- | :--------------------------- | | + | 加法運算，字符串連接運算 | | - | 減法運算 | | * | 乘法運算 | | / | 除法運算 | | % | 取模運算，兩個數(shù)字相除取余數(shù) | | ++、— | 自增自減運算 |

Java中, 整數(shù)使用以上運算符 ,無論怎么計算, 也不會得到小數(shù)

public static void main(String[] args) { int i = 1234;System.out.println(i/1000*1000);//計算結(jié)果是1000 }

一切基本數(shù)據(jù)類型與 String字符串用 + 都是拼接形成新的 字符串

自增運算符 : ++

自減運算符 : --

使用格式 : 寫在變量名稱之前, 后綴寫在變量名稱之后, 例如: ++num, 也可以num++

使用方式 :

? 單獨使用 : ++num, num++ 沒有任何區(qū)別

? 混合使用 :

? A - 如果是前++ ,那么變量立刻馬上+1,然后拿著結(jié)果使用 [先加后用]

? B - 如果是后++,那么使用變量本來的數(shù)值,然后再讓變量+1 [先用后加]

注意事項 : 只有變量才能使用自增, 自減運算符; 常量不可改變, 所以不能用

賦值運算符

| 賦值運算符包括： | | | :--------------- | :----- | | = | 等于號 | | += | 加等于 | | -= | 減等于 | | *= | 乘等于 | | %= | 取模等 | | /= | 除等于 |

賦值運算符 : 就是將符號左邊的值, 賦給左邊的變量

public static void main(String[] args){ int i = 5; i+=5;//計算方式 i=i+5 變量i先加5，再賦值變量i System.out.println(i); //輸出結(jié)果是10 }

比較運算符

| 比較運算符包括： | | | :--------------- | :----------------------------------------------------------- | | == | 比較符號兩邊數(shù)據(jù)是否相等，相等結(jié)果是true。 | | > | 比較符號左邊的數(shù)據(jù)是否大于右邊的數(shù)據(jù)，如果大于結(jié)果是true。 | | < | 比較符號左邊的數(shù)據(jù)是否小于右邊的數(shù)據(jù)，如果小于結(jié)果是true。 | | >= | 比較符號左邊的數(shù)據(jù)是否大于或者等于右邊的數(shù)據(jù)，如果小于結(jié)果是true。 | | <= | 比較符號左邊的數(shù)據(jù)是否小于或者等于右邊的數(shù)據(jù)，如果小于結(jié)果是true。 | | != | 不等于符號 ，如果符號兩邊的數(shù)據(jù)不相等，結(jié)果是true。 |

比較運算符 : 兩個數(shù)據(jù)之間比較的運算, 運算結(jié)果都是布爾值 true 或者 false

邏輯運算符

| 邏輯運算符包括： | | | :--------------- | :----------------------------------------------------------- | | && 短路與 | 1. 兩邊都是true，結(jié)果是true 2. 一邊是false，結(jié)果是false 短路特點：符號左邊是false，右邊不再運算 [全真為真] | | ！ 取反 | 1. ! true 結(jié)果是false 2. ! false結(jié)果是true | | || 短路或 | 1. 兩邊都是false，結(jié)果是false 2. 一邊是true，結(jié)果是true 短路特點： 符號左邊是true，右邊不再運算。 [一真為真] |

三元運算符

運算法則 : 數(shù)據(jù)類型 變量名 = 布爾類型表達(dá)式 ? 結(jié)果1 : 結(jié)果2

當(dāng)布爾類型表達(dá)式值為true, 取結(jié)果1賦值給變量 ; 否則即當(dāng)布爾類型表達(dá)式值為false, 取結(jié)果2賦值給變量;

9 JDK的JShell的簡單使用

當(dāng)我們編寫的代碼非常少的時候, 而又不愿意編寫類, main方法, 也不愿意去編譯和運行,就要使用JShell命令

在cmd當(dāng)中 輸入 jshell進(jìn)入,,,,,,,輸入 /exit 退出命令

編譯器的的優(yōu)化 :

• 對于 byte/short/char 三種類型來說, 如果右側(cè)賦值的數(shù)值沒有超過范圍, 那么javac編譯器將會自動隱含地(強(qiáng)轉(zhuǎn))為我們補(bǔ)上一個(byte)(short)(char); 如果右側(cè)超過了左側(cè)的范圍, 那么直接編譯報錯
• 在給變量賦值的時候, 如果右側(cè)的表達(dá)式當(dāng)中全都是常量, 沒有任何變量, 那么編譯器javac 將會直接將若干個常量表達(dá)式計算得到結(jié)果; short = 5 + 8; // 等號右邊全都是常量, 沒有任何變量參與運算編譯之后, 得到的.class 字節(jié)碼文件當(dāng)中相當(dāng)于[直接就是] : short result = 13;右側(cè)的常量結(jié)果數(shù)值, 沒有超過左側(cè)范圍, 所以正確; 這稱之為"編譯器的常量優(yōu)化"

10 流程控制

順序結(jié)構(gòu)

在一個程序執(zhí)行的過程中，各條語句的執(zhí)行順序?qū)Τ绦虻慕Y(jié)果是有直接影響的。也就是說，程序的流程對運行結(jié)果 有直接的影響。所以，我們必須清楚每條語句的執(zhí)行流程。而且，很多時候我們要通過控制語句的執(zhí)行順序來實現(xiàn) 我們要完成的功能。

public static void main(String[] args){ //順序執(zhí)行，根據(jù)編寫的順序，從上到下運行 System.out.println(1); System.out.println(2); System.out.println(3); }

判斷語句

if

if(關(guān)系表達(dá)式)｛ 語句體; ｝public static void main(String[] args){System.out.println("開始");// 定義兩個變量int a = 10;int b = 20;//變量使用if判斷if (a == b){System.out.println("a等于b");}int c = 10;if(a == c){System.out.println("a等于c");}System.out.println("結(jié)束"); ｝

執(zhí)行流程 :

首先判斷關(guān)系表達(dá)式看其結(jié)果是true還是false

如果是true就執(zhí)行語句體

如果是false就不執(zhí)行語句體

if.....else

if(關(guān)系表達(dá)式) { 語句體1; }else { 語句體2; }

執(zhí)行流程 :

首先判斷關(guān)系表達(dá)式看其結(jié)果是true還是false

如果是true就執(zhí)行語句體1

如果是false就執(zhí)行語句體2

if ....else if ...else

if (判斷條件1) { 執(zhí)行語句1; } else if (判斷條件2) { 執(zhí)行語句2; } ... }else if (判斷條件n) { 執(zhí)行語句n; } else { 執(zhí)行語句n+1; }

執(zhí)行流程 :

首先判斷關(guān)系表達(dá)式1看其結(jié)果是true還是false

如果是true就執(zhí)行語句體1

如果是false就繼續(xù)判斷關(guān)系表達(dá)式2看其結(jié)果是true還是false

如果是true就執(zhí)行語句體2

如果是false就繼續(xù)判斷關(guān)系表達(dá)式…看其結(jié)果是true還是false

…

如果沒有任何關(guān)系表達(dá)式為true，就執(zhí)行語句體n+1。

public static void main(String[] args) {// x和y的關(guān)系滿足如下：// x>=3 y = 2x + 1;//‐1<=x<3 y = 2x;// x<=‐1 y = 2x – 1;// 根據(jù)給定的x的值，計算出y的值并輸出。// 定義變量int x = 5;int y;if (x>= 3) {y = 2 * x + 1;} else if (x >= ‐1 && x < 3) {y = 2 * x;} else {y = 2 * x ‐ 1;}System.out.println("y的值是："+y); }

選擇語句

switch(表達(dá)式) {case 常量值1:語句體1;break;case 常量值2:語句體2;break;...default:語句體n+1;break; }

執(zhí)行流程 :

首先計算出表達(dá)式的值

其次，和case依次比較，一旦有對應(yīng)的值，就會執(zhí)行相應(yīng)的語句，在執(zhí)行的過程中，遇到break就會結(jié) 束。

最后，如果所有的case都和表達(dá)式的值不匹配，就會執(zhí)行default語句體部分，然后程序結(jié)束掉。

public static void main(String[] args) {//定義變量，判斷是星期幾int weekday = 6;//switch語句實現(xiàn)選擇switch(weekday) {case 1:System.out.println("星期一");break;case 2:System.out.println("星期二");break;case 3:System.out.println("星期三");break;case 4:System.out.println("星期四");break;case 5:System.out.println("星期五");break;case 6:System.out.println("星期六");break;case 7:System.out.println("星期日");break;default:System.out.println("你輸入的數(shù)字有誤");break;} }

switch語句中, 表達(dá)式的數(shù)據(jù)類型 ,可以是byte, short, int ,char ,enum(枚舉), 還可以是字符串

循環(huán)語句

循環(huán)語句可以在滿足循環(huán)條件的情況下, 反復(fù)執(zhí)行某一段代碼, 這段被重復(fù)執(zhí)行的代碼被稱為循環(huán)體語句, 當(dāng)反復(fù)執(zhí)行這個循環(huán)體時, 需要在合適的時候把循環(huán)判斷條件修改為false, 從而結(jié)束循環(huán), 否則循環(huán)將一直執(zhí)行下去, 形成死循環(huán)

for循環(huán)語句表達(dá)式

for(初始化表達(dá)式①; 布爾表達(dá)式②; 步進(jìn)表達(dá)式④){循環(huán)體③ }

執(zhí)行流程 :

執(zhí)行順序：①②③④>②③④>②③④…②不滿足為止。

①負(fù)責(zé)完成循環(huán)變量初始化

②負(fù)責(zé)判斷是否滿足循環(huán)條件，不滿足則跳出循環(huán)

③具體執(zhí)行的語句

④循環(huán)后，循環(huán)條件所涉及變量的變化情況

public static void main(String[] args) {//定義變量從0開始，循環(huán)條件為<10for(int x = 0; x < 10; x++) {System.out.println("HelloWorld"+x);} } 循環(huán)練習(xí)：使用循環(huán)，計算1-100之間的偶數(shù)和 public static void main(String[] args) {//1.定義一個初始化變量,記錄累加求和,初始值為0int sum = 0;//2.利用for循環(huán)獲取1‐100之間的數(shù)字for (int i = 1; i <= 100; i++) {//3.判斷獲取的數(shù)組是奇數(shù)還是偶數(shù)if(i % 2==0){//4.如果是偶數(shù)就累加求和sum += i;}}//5.循環(huán)結(jié)束之后,打印累加結(jié)果System.out.println("sum:"+sum); }

do.......while循環(huán)表達(dá)式

初始化表達(dá)式① do{ 循環(huán)體③ 步進(jìn)表達(dá)式④ }while(布爾表達(dá)式②);輸出10次HelloWorld public static void main(String[] args) {int x=1;do {System.out.println("HelloWorld");x++;}while(x<=10); }

do...while循環(huán)的特點：無條件執(zhí)行一次循環(huán)體，即使我們將循環(huán)條件直接寫成false，也依然會循環(huán)一次。這樣的 循環(huán)具有一定的風(fēng)險性，因此初學(xué)者不建議使用do...while循環(huán)。

跳出語句

break : 終止swtich或者循環(huán)

public static void main(String[] args) {for (int i = 1; i<=10; i++) {//需求:打印完兩次HelloWorld之后結(jié)束循環(huán)if(i == 3){break;}System.out.println("HelloWorld"+i);}}

continue : 結(jié)束本次循環(huán), 繼續(xù)下一次的循環(huán)

public static void main(String[] args) {for (int i = 1; i <= 10; i++) {//需求:不打印第三次HelloWorldif(i == 3){continue;}System.out.println("HelloWorld"+i);} }

死循環(huán) : 也就是循環(huán)中的條件永遠(yuǎn)為true，死循環(huán)的是永不結(jié)束的循環(huán)。例如：while(true){}

嵌套循環(huán) 所謂嵌套循環(huán)，是指一個循環(huán)的循環(huán)體是另一個循環(huán)。比如for循環(huán)里面還有一個for循環(huán)，就是嵌套循環(huán)?？偣驳难h(huán)次數(shù)=外循環(huán)次數(shù)*內(nèi)循環(huán)次數(shù)

外循環(huán)一次, 內(nèi)循環(huán)多次

for(初始化表達(dá)式①; 循環(huán)條件②; 步進(jìn)表達(dá)式⑦) {for(初始化表達(dá)式③; 循環(huán)條件④; 步進(jìn)表達(dá)式⑥) {執(zhí)行語句⑤;} }

11 開發(fā)工具 Intellij IDEA

IDEA是一個專門針對java的集成開發(fā)工具(IDE), 由java語言編寫, 所以, 需要有JRE運行環(huán)境并配置好環(huán)境變量; 他可以極大的提升我們的開發(fā)效率, 可以自動編譯, 檢查錯誤

項目Project --> 模塊Module --> 包 Packpage

IDE的 HelloWorld 在模塊的src目錄下 新建 java class,寫上 psvm 快捷生成 main()

IDE的基本設(shè)置 : 更改自動補(bǔ)全為 Alt+/

IDEA常用快捷鍵

| 快捷鍵 | 功能 | | -------------------- | -------------------------------------- | | Alt+Enter | 導(dǎo)入包, 自動修正代碼 | | Ctrl+Y | 刪除光標(biāo)所在行 | | Ctrl+D | 復(fù)制光標(biāo)所在行的內(nèi)容, 插入光標(biāo)位置下面 | | Ctrl+Alt+L | 格式化代碼 | | Ctrl+/ | 單行注釋, 再按取消注釋 | | cTRL+Shift+/ | 選中代碼注釋, 多行注釋, 再按取消注釋 | | Alt+Ins | 自動生成代碼, toString, get, set等方法 | | Alt+Shift+上下箭頭 | 移動當(dāng)前代碼行 |

刪除模塊: 選中模塊delete, 或者右鍵Remove Module

導(dǎo)入模塊 : File --> Project Structure --> + -->import Module --> 選擇對應(yīng)的目錄-->一直next,next

12 方法

定義 : 就是將一個功能抽取出來, 把代碼單獨定義在一個大括號內(nèi), 形成一個單獨的功能;當(dāng)我們需要這個功能的時候,就可以去調(diào)用, 這樣既實現(xiàn)了代碼的復(fù)用性, 也解決了代碼冗余的現(xiàn)象

定義格式 :

修飾符 返回值類型 方法名 (參數(shù)列表) {代碼 ...return ; }public static void main (String[] args) {方法體 ...return 返回值; }

解釋 :

• 修飾符 : 目前固定寫法 public static
• 返回值類型 : 目前固定寫法 void, 其他返回值會在后面接觸
• 方法名: 我們定義的方法名 : 滿足標(biāo)識符的規(guī)范, 用來調(diào)用方法
• 參數(shù)列表 :方法在運算過程中的未知數(shù)據(jù), 調(diào)用者調(diào)用方法時傳遞
• return : 將方法執(zhí)行后的結(jié)果數(shù)據(jù)帶給調(diào)用者，方法執(zhí)行到 return ，整體方法運行結(jié)束
• 結(jié)果 : 方法的返回值

注意事項 :

• 方法的定義位置在類中,在main()外面, 在 main中調(diào)用,先后順序無所謂,和調(diào)用順序有關(guān)
• 返回值類型, 必須要和 return語句返回的類型相同, 否則編譯失敗
• 不能用輸出語句調(diào)用 void 類型的方法; 因為方法執(zhí)行后沒得結(jié)果,也不打印出任何內(nèi)容
• 一個方法中可以有多個return語句,但是只能保證同時只能有一個被執(zhí)行, return不能連寫

方法的調(diào)用方式:

• 單獨調(diào)用, 方法名稱(參數(shù));
• 打印調(diào)用, System.out.println(Sum(3,5));
• 賦值調(diào)用, 數(shù)據(jù)類型 變量名稱 = Sum(3,5);

方法的有無參數(shù):

有參數(shù): 小括號當(dāng)中有內(nèi)容, 當(dāng)一個方法需要一些數(shù)據(jù)條件,才能完成任務(wù)的時候,就是有參數(shù) 例如兩數(shù)相加, 必須知道兩個數(shù)字各自是多少, 才能相加無參數(shù): 小括號當(dāng)中留空, 一個方法不需要任何數(shù)據(jù)條件, 自己就能獨立完成任務(wù),就是無參數(shù) 例如定義一個方法, 打印10次Helloworld

有無返回值

package cn.itcast.day04.demo02;public class Demo04Return {public static void main(String[] args) {int num = getSum(10,20);System.out.println("返回值"+ num);System.out.println("=============");printSum(2,3);}public static int getSum(int a, int b){int res = a + b;return res;}public static void printSum(int a,int b){int res = a + b;System.out.println(res);}}

getSum就是有返回值的方法; printSum就是無返回值的方法

練習(xí) 1 : 定義一個方法, 用來判斷兩個數(shù)字是否相同

public class Demo01MethodSame(){public static void main(String[] args) {System.out.println(isSame(10,20)) // false}public static boolean isSame(int a,int b){boolean same;if (a == b){same = true;}else{same = fasle;}boolean same = a = b?true:fasle;boolean same = a==breturn same;return a == b; }}

練習(xí)2 : 定義一個方法, 永安里打印指定次數(shù)的HelloWorld

public class Demo03MethodPrint {public static void main(String[] args) {printCount(8);}/*三要素返回值類型 : void方法名 : printCount參數(shù)列表 : 到底打印多少次, 告訴我?guī)状?就打印幾次 次數(shù) int :num*/public static void printCount(int num){for (int i = 0; i < num; i++) {System.out.println("HelloWorld" + (i+方法1));}} }

方法定義的三要素 : 返回值類型, 方法名, 參數(shù)列表 [返回值類型必須與return返回的類型相同]

方法重載

定義 : 同一個類中, 允許重載一個以上的同名方法, 只要他們的參數(shù)列表不同即可, 與修飾符和返回值類型無關(guān)

參數(shù)列表 : 個數(shù)不同, 數(shù)據(jù)類型不同, 順序不同

重載方法調(diào)用 : JVM通過方法的參數(shù)列表, 調(diào)用不同的方法

13 數(shù)組

定義 : 是一種容器, 可以同時存放多個數(shù)據(jù)值

特點 :

數(shù)組是一種引用數(shù)據(jù)類型

數(shù)組當(dāng)中的多個數(shù)據(jù), 類型必須統(tǒng)一

數(shù)組的長度在程序運行期間不可改變

數(shù)組的創(chuàng)建 , 也叫做數(shù)組的初始化

動態(tài)初始化(指定長度) : 在創(chuàng)建數(shù)組的時候, 直接指定數(shù)組當(dāng)中的數(shù)據(jù)元素的個數(shù)

靜態(tài)初始化(指定內(nèi)容) : 在創(chuàng)建數(shù)組的時候, 不直接指定數(shù)據(jù)個數(shù)多少, 而是直接將具體的數(shù)據(jù)內(nèi)容指定

動態(tài)初始化數(shù)組的格式 : 數(shù)據(jù)類型[] 數(shù)組名稱 = new 數(shù)據(jù)類型[數(shù)組長度];

動態(tài)初始化時數(shù)組的元素會自動擁有一個默認(rèn)值, 為 0; 根據(jù)數(shù)組的類型自動擁有

靜態(tài)初始化時數(shù)組的元素會其實也會自動擁有一個默認(rèn)值, 為 0; 只不過系統(tǒng)馬上將默認(rèn)值替換為了大括號當(dāng)中的具體數(shù)值

解析含義 :

左側(cè)數(shù)據(jù)類型 : 也就是數(shù)組當(dāng)中保存的數(shù)據(jù), 全都是統(tǒng)一的什么類型

左側(cè)中的括號 : 代表我是一個數(shù)組

左側(cè)的數(shù)組名稱 : 給數(shù)組取一個名字

右側(cè)中的new : 代表創(chuàng)建數(shù)組的動作

右側(cè)數(shù)據(jù)類型 : 必須和左邊的數(shù)據(jù)類型保持一致

右側(cè)括號中的長度 : 也就是數(shù)組當(dāng)中, 到底可以保存多少個數(shù)據(jù), 是一個int數(shù)字

靜態(tài)初始化數(shù)組的格式 : 數(shù)據(jù)類型[] 數(shù)組名稱 = new 數(shù)據(jù)類型[]{元素1,元素2,元素3};

省略初始化數(shù)組的格式 : 數(shù)據(jù)類型[] 數(shù)組名稱 = {元素1,元素2,元素3};

// 直接打印數(shù)組名稱, 得到的是數(shù)組對應(yīng)的, 內(nèi)存地址的哈希值int[] array = {10,20,30} System.out.println(array); // [I@75412c2f 十六進(jìn)制

數(shù)組的訪問

索引 : 每一個存儲到數(shù)組的元素，都會自動的擁有一個編號，從0開始，到length-1結(jié)束, 這個自動編號稱為數(shù)組索引(index)，可以通過數(shù)組的索引訪問到數(shù)組中的元素。

格式 : 數(shù)組名[索引]

數(shù)組的賦值 : array[索引] = 具體的數(shù)值

Java的內(nèi)存劃分

Java的內(nèi)存需要劃分為五個部分:

1 棧(Stack) : 存放的都是方法中的局部變量, 方法的運行一定要在棧當(dāng)中; 局部變量: 方法的參數(shù),或者是方法{}內(nèi)部的變量, 作用域: 一旦超過作用域, 立刻從棧內(nèi)存才能當(dāng)中消失

2 堆(Heap) : 凡是 new 出來的東西,都在堆當(dāng)中; 堆內(nèi)存里面的東西都有一個地址值 : 16 進(jìn)制, 堆內(nèi)存里面的數(shù)據(jù), 都有默認(rèn)值; 整數(shù) --> 默認(rèn)為0; 浮點數(shù) --> 默認(rèn)為0.0; 字符 --> 默認(rèn)為'u0000'; 布爾值 --> 默認(rèn)為false; 引用類型 --> 默認(rèn)為null

3 方法區(qū)(Method Area) : 存儲.class 相關(guān)信息, 包含方法的信息

4 本地方法棧(Native Method Stack) : 與操作系統(tǒng)相關(guān)

5 寄存器(pc Register) : 與CPU相關(guān)

一個數(shù)組的從無到有

兩個數(shù)組的內(nèi)存圖

兩個引用指向同一個數(shù)組的問題

把 arrayB = arrayA 把a(bǔ)rrayA的內(nèi)存地址賦值給arrayB

public class Demo05ArraySame {public static void main(String[] args) {int[] arrayA = new int[3]; // 初始化一個數(shù)組System.out.println(arrayA); // 地址值System.out.println(arrayA[0]); // 0System.out.println(arrayA[1]); // 0System.out.println(arrayA[2]); // 0arrayA[1] = 20;arrayA[2] = 30;System.out.println(arrayA); // 地址值System.out.println(arrayA[0]); // 0System.out.println(arrayA[1]); // 20System.out.println(arrayA[2]); // 30int[] arrayB = arrayA;System.out.println(arrayB); // 地址值System.out.println(arrayB[0]); // 0System.out.println(arrayB[1]); // 0System.out.println(arrayB[2]); // 0arrayB[1] = 200;arrayB[2] = 300;System.out.println(arrayB); // 地址值System.out.println(arrayB[0]); // 0System.out.println(arrayB[1]); // 200System.out.println(arrayB[2]); // 300System.out.println("=================");System.out.println(arrayA[1]); // 200System.out.println(arrayA[2]); // 300} }

操作 arrayA和arrayB, 他們倆其實就是一個數(shù)組

空指針異常

所有的引用類型變量, 都可以賦值為一個 null 值,但是代表其中什么都沒有

數(shù)組必須進(jìn)行new初始化才能使用其中的元素

如果只是賦值了一個null,沒有進(jìn)行new創(chuàng)建,那么將會發(fā)生空指針異常 NullPointerException

數(shù)組的長度屬性

每個數(shù)組都具有長度，而且是固定的，在程序運行期間不可變,Java中賦予了數(shù)組的一個屬性，可以獲取到數(shù)組的長度，語句為： 數(shù)組名.length ，屬性length的執(zhí)行結(jié)果是數(shù)組的長度，int類型結(jié)果。由次可以推斷出，數(shù)組的最大索引值為 數(shù)組名.length-1 。

int[] arrayC = new int[3]; arrayC = new int[5]; System.out.println(arrayC) // 此時并沒有改變數(shù)組的長度,而是新創(chuàng)建了一個數(shù)組, 改變了arrayC的引用 --> 指向新的數(shù)組

數(shù)組的遍歷輸出

public static void main(String[] args) {int[] arr = { 1, 2, 3, 4, 5 };for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);} }

數(shù)組獲取最大值元素

public static void main(String[] args) {int[] arr = { 5, 15, 2000, 10000, 100, 4000 };//定義變量，保存數(shù)組中0索引的元素int max = arr[0];//遍歷數(shù)組，取出每個元素for (int i = 1; i < arr.length; i++) {//遍歷到的元素和變量max比較//如果數(shù)組元素大于maxif (arr[i] > max) {//max記錄住大值max = arr[i];}}System.out.println("數(shù)組最大值是： " + max); }

數(shù)組反轉(zhuǎn)

blic static void main(String[] args) {int[] arr = { 1, 2, 3, 4, 5 };/*循環(huán)中定義變量min=0最小索引初始化語句 min=0最小索引,max=arr.length‐1最大索引條件判斷 min <= max步進(jìn)表達(dá)式 min++,max‐‐*/for (int min = 0, max = arr.length ‐ 1; min <= max; min++, max‐‐) {//利用第三方變量完成數(shù)組中的元素交換int temp = arr[min];arr[min] = arr[max];arr[max] = temp;}// 反轉(zhuǎn)后，遍歷數(shù)組for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);} }

數(shù)組作為方法的參數(shù)傳遞

數(shù)組作為方法的參數(shù)傳遞, 傳遞的參數(shù)是數(shù)組的內(nèi)存地址

public static void main(String[] args) {int[] arr = { 1, 3, 5, 7, 9 };//調(diào)用方法，傳遞數(shù)組printArray(arr); } /* 創(chuàng)建方法，方法接收數(shù)組類型的參數(shù) 進(jìn)行數(shù)組的遍歷 */ public static void printArray(int[] arr) {for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);} }

數(shù)組作為方法的返回值返回

數(shù)組作為方法的返回值返回, 返回的是數(shù)組的內(nèi)存地址

一個方法可有0, 1, 多個參數(shù),但是只能有0或者1個返回值, 不能有多個返回值

如果希望一個方法當(dāng)中產(chǎn)生多個結(jié)果數(shù)據(jù)返回, 使用一個數(shù)組作為返回值類型即可

public static void main(String[] args) {//調(diào)用方法，接收數(shù)組的返回值//接收到的是數(shù)組的內(nèi)存地址int[] res = cal(10,20,30);for (int i = 0; i < res.length; i++) {System.out.println("總和:"+ res[0]);System.out.println("平均數(shù):"+ res[0]);} } /* 創(chuàng)建方法，返回值是數(shù)組類型 return返回數(shù)組的地址 */ public static int[] cal(int a,int b,int c) {int sum = a+b+c; // 總和int avg = sum /3; // 平均數(shù)int[] arr = {sum,avg};return arr; }

方法的參數(shù)為基本數(shù)據(jù)類型時,傳遞的是數(shù)據(jù)值; 方法的參數(shù)為引用類型時, 傳遞的是地址值

同理, 引用類型作為方法的返回值時, 返回的也是地址值

總結(jié)

以上是生活随笔為你收集整理的java 左边补0_java基础知识的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。