Java基礎語法
 計算機基礎
 1.什麽(me) 是二進製？
2.什麽(me) 是字節？
3.命令提示符
 Java語言基礎
 JRE和JDK、JVM
關(guan) 鍵字和標識符
 常量和變量
 數據類型轉換
 運算符
 程序流程
 方法

Java基礎語法

計算機基礎

1.什麽是二進製？

二進製數隻包含0和1，每一個(ge) 0或者1都是一個(ge) bit（位）。
我們(men) 常用的十進製如何轉換成二進製：

2.什麽是字節？

我們(men) 知道計算機中的數據都是由1或者0組成，每個(ge) 0或1都是一個(ge) bit，每8個(ge) bit就是一個(ge) 字節(byte）。
字節是數據存儲(chu) 的最小單位。
1 TB = 1024 GB---->1 GB = 1024 MB ---->1 MB = 1024 KB---->1 KB = 1024 B

3.命令提示符

啟動：win+R
切換盤符：盤符:
退出：exit
進入文件夾：cd+文件夾名稱
查看目錄：dir
清屏：cls
進入多級文件夾： cd+\IdeaProjects\javaBasic\java
返回上一層：cd…
返回根目錄：cd </br>

Java語言基礎

JRE和JDK、JVM

JRE(Java Runtime Enviroment),Java運行環境，如果隻是需要在該計算機上運行Java應用，那麽(me) 隻需要安裝JRE即可。

JDK(Java Development Kit),如果想要開發，就必須安裝JDK。

特別注意：JDK安裝路徑最好不要有空格或者中文。

關鍵字和標識符

關(guan) 鍵字的特點：

完全小寫的字母
在增強版的記事本或者IDE中有特殊的顏色

標識符：自己命名的類名，方法名等。
命名規則：

由字母、數字、下劃線、美元符號組成
不能由數字開頭
不能是Java保留字

常量和變量

常量

什麽(me) 是常量？
常量就是在程序運行期間，不會(hui) 改變的量。

常量的分類
字符串常量：凡是用雙引號括起來的都是字符串常量，例如：“abc”,“110”,“Hello”…
字符常量：凡是用單引號括起來的單個(ge) 字符，就叫字符常量。例如：‘A’,‘a’,‘1’,‘張’
整型常量：直接寫(xie) 上的數字，沒有小數點。例如：123,200，-23
浮點型常量：直接寫(xie) 上的數字，有小數點。例如：3.14,0.0
布爾常量：true或false
空常量：null。代表沒有任何數據

public class Demo01Const{ public static void main(String[] args){ // 字符串常量 System.out.println("ABC"); System.out.println(""); System.out.println("XYZ"); // 整數常量 System.out.println(50); System.out.println(-30); // 浮點常量 System.out.println(3.14); System.out.println(0.0); System.out.println(-24.0); // 字符常量 System.out.println('A'); System.out.println('a'); //System.out.println('');單引號中間有且僅(jin) 有一個(ge) 字符，沒有不行，編譯出錯 // 布爾常量 System.out.println(true); System.out.println(false); //空常量 null,不能直接打印 } }

數據類型

數據類型分為(wei) 兩(liang) 類：

基本數據類型：整型，浮點型，布爾型，字符型
引用數據類型：字符串，數組，類，接口，Lamda

基本數據類型：
整型：byte，short，int，long
浮點型：float，double
字符型：char
布爾型：boolean

基本數據類型注意事項：
1.字符串不是基本數據類型，而是引用類型。
2.浮點型可能是一個(ge) 近似值，而不是精確值。
3.數據範圍不一定與(yu) 字節數相關(guan) ，例如float的範圍比long要廣，但是它隻占4個(ge) 字節。
4.浮點數默認是double類型，要使用float類型，需要加上後綴F/f，但是建議使用F。
5.整數默認為(wei) int類型，要使用long類型，需要加上後綴L/l，但是建議使用L。

public class Demo01DataType{ public static void main(String[] args){ System.out.println(1024);//默認是int類型 System.out.println(3.14);//默認是double類型 //左邊是long類型，右邊是int類型，數據類型不一致，會(hui) 發生數據轉換， //int類型數據範圍比long類型數據範圍小，可以發生自動類型轉換 long num1 = 10; System.out.println(num1); //左邊是double類型，右邊是float類型，數據類型不一致，可以發生數據類型轉換 //float---->double float數據範圍比double小，可以是發生自動類型轉換 double num2 = 2.5F; System.out.println(num2); //左邊是float類型，右邊是long類型，數據類型不一致，可以發生數據類型轉換 //long---->float long類型數據範圍比float類型小，可以發生自動類型轉換 float num3 = 30L; System.out.println(num3);//30.0 } }

變量

什麽(me) 是變量？
就是在程序運行期間，會(hui) 發生改變的量。

創建一個(ge) 變量的格式
① 數據類型變量名稱;//創建一個(ge) 變量
變量名稱 = 數據值;//賦值，將右邊的數據值，賦值給左邊的變量
② 數據類型變量名稱 = 數據值;

public class Demo02Variable{ public static void main(String[] args){ //使用格式①創建變量 int num1; num1=1; System.out.println(num1); //改變變量當中的值 num1=20; System.out.println(num1); //使用格式② int num2 = 5; System.out.println(num2); //byte num3 = 129; //System.out.println(num3); byte num3 = 64; System.out.println(num3);//64 short num4 = 400; System.out.println(num4);//400 long num5 = 3000000000L; System.out.println(num5);//3000000000 float num6 = 3.2444F; System.out.println(num6);//3.2444 double num7 = 3.14; System.out.println(num7);//3.14 char ch1 = 'A'; System.out.println(ch1);//A char ch2 = '2'; System.out.println(ch2);//2 char ch3 = '我'; System.out.println(ch3);//我 boolean b1 = true; System.out.println(b1);//true b1 = false; System.out.println(b1);//false boolean b2 = b1; System.out.println(b2);//false } }

使用變量的注意事項

變量的命名不能重複。
在使用byte和short的時候要注意它們的範圍，如果超出範圍會編譯錯誤。
在使用float和long類型時，注意要加後綴。
變量的使用不能超出其作用域。（作用域：就是從變量命名的地方開始，直到該變量直接所屬的大括號結束為止）
沒有進行賦值的變量不能直接使用。
可以直接定義多個變量，但是不建議使用。

public class Demo03VariableNotice{ public static void main(String[] args){ int num1 = 10; System.out.println(num1); //int num1 = 20;錯誤，變量名不能重複。 float num2 = 3.14F;//如果不加F會(hui) 產(chan) 生錯誤。 System.out.println(num2); long num3 = 30000000000L; System.out.println(num3); //byte num4 = 128; 注意byte的範圍是-128~127，不能超出範圍 byte num4 = 12; System.out.println(num4); short num5 = 400; System.out.println(num5); //沒有賦值的變量不能使用 //int num6; //System.out.println(num6); //此時還沒有命名變量，無法使用。 //System.out.println(num6); int num6 = 2; System.out.println(num6); //可以這麽(me) 使用，但是不建議。 int a = 10,b = 20,c = 30; System.out.println(a); System.out.println(b); System.out.println(c); } }

數據類型轉換

什麽(me) 是數據類型轉換？
當數據類型不一樣時，就會(hui) 發生數據類型轉換。

數據類型轉換的分類：

自動類型轉換(隱式)：
①特點：代碼不需要進行處理，自動完成
②規則：數據範圍由小到大

2.強製類型轉換(顯式)：
①特點：代碼需要進行格式處理，不能自動完成
②格式：數據類型變量名稱 = （範圍小的類型）原本範圍大的數據

注意事項：

強製類型轉換有可能導致精度丟失、數據溢出等。
byte、short、char類型都可以進行數學運算。
byte、short、char類型在進行數學運算時，都被提升成了int類型，再進行計算。
boolean類型不能進行數據轉換。

public class Demo02DataType{ public static void main(String[] args){ //左邊是int類型，右邊是long類型，會(hui) 發生數據類型轉換 //long---->int ,long類型範圍比int類型大，不能發生自動類型轉換，需要強製類型轉換 //進行格式處理：範圍小的數據類型範圍小的變量名 = (範圍小的數據類型)原本範圍大的數據； int num =(int)100L; System.out.println(num); //左邊是int類型，右邊是long類型，會(hui) 發生數據類型轉換 //long--->int long比int範圍要大，所以發生強製類型轉換 //但是發生了數據溢出，因為(wei) int類型裝不下6000000000 int num1 = (int) 6000000000L; System.out.println(num1);//1705032704 //float---->int 強製轉換，發生精度丟(diu) 失，這裏不是四舍五入 int num2 = (int) 3.99F; System.out.println(num2);//3 //我們(men) 都知道計算機底層都是二進製數，所以A也是以二進製數的形式來存儲(chu) ， char ch1 = 'A'; System.out.println(ch1+1);//66 證明這裏的'A'被當做65來進行運算 byte b1 = 40; byte b2 = 50; int result1 = b1+b2;//會(hui) 報錯，不兼容的類型。原因：就是第三個(ge) 注意事項，當進行數學運算時，b1和b2都已經被提升成了int類型，左右兩(liang) 邊類型不一致 //需要發生強製類型轉換，所以把result1的類型轉換成int System.out.println(result1); short s1 = 60; //short result2 = b1+s1; 同上，會(hui) 報錯，如果想要的結果是short類型，那麽(me) 必須進行強製類型轉換 short result2 =(short)(b1+s1); System.out.println(result2); } }

ASCII碼表

什麽(me) 是ASCII碼表？
ASCII：American Standard Code of Information Inchange 美國信息交換標準代碼
還有Unicode表，就是數字和字符的對照關(guan) 係表。

public class Demo03DataTypeChar{ public static void main(String[] args){ char ch1 = '1'; System.out.println(ch1+0); char ch2 = 'A'; System.out.println(ch2+2);//67 //左邊是int類型，右邊是char類型，左右不一致，發生數據類型轉換 //char---->int 範圍小向範圍大轉換，自動轉換，不需要強製類型轉換 int num = 'c'; System.out.println(num);//99 int ch3 = '中'; System.out.println(ch3);//20013 } }

運算符

什麽(me) 是運算符？
就是進行特定操作的符號。
什麽(me) 是表達式？
就是用運算符連接起來的式子。

四則運算符和加號的特定用法

四則運算符，+，-，*,/,%;其中包括加，減，乘，除，%代表取模，即取餘(yu) 數。

public class Demo04Operator{ public static void main(String[] args){ System.out.println(20+30);//50 int a = 10; int b = 20; //會(hui) 先計算表達式的值，再進行打印 System.out.println(a-b);//-10 System.out.println(a*10);//100 //除法，隻看商 int result1 = 10/3; System.out.println(result1);//3 //如果想要獲得餘(yu) 數，用取模運算 int x = 14; int y = 3; int result2 = x%y; System.out.println(result2);//2 //int + double ---->double + double ----->double double result3 = x + 2.5; System.out.println(result3);//16.5 } }

"+"常見的三種用法：

正常的加法運算
對於char類型來說，在計算前會被提升為int類型
用於連接字符串（注意事項：任何數據類型和字符串相連接，都會變成字符串)

public class Demo05Plus{ public static void main(String[] args){ String str1 = "Hello"; System.out.println("Hello"); System.out.println("Hello"+"World");//HelloWorld String str2 = "Java"; //String + int --->String + String ---->String System.out.println(str1+20);//Java20 System.out.println(str1+20+30);//Java2030 System.out.println(str1+(20+30));//Java50 } }

自增、自減運算符

使用方式：++可以在前，也可以在後，例如：++n或者n++。
使用區別：
1.單獨使用：++在前和在後沒有任何區別，獨自形成一個(ge) 步驟（前提是不與(yu) 任何其他操作混合）
2.混合使用：當混合使用時，++在前和在後有【重大區別】：
a.++在前時，變量立刻+1，然後再參與(yu) 其他運算【先加後用】
b.++在後時，變量首先按照原來的值參與(yu) 其他運算，然後再+1 【先用後加】
注意事項：隻有是變量才能使用自增、自減符號，常量無法使用。

public class Demo06Operator{ public static void main(String[] args){ //單獨使用的情況，沒有區別 int num1 = 10; ++num1; System.out.println(num1);//11 int num2 = 20; num2++; System.out.println(num2);//21 System.out.println("=============================================================="); //混合使用，例如與(yu) 打印操作混合 int num3 = 30; System.out.println(++num3);//31 System.out.println(num3);//31 int num4 = 40; System.out.println(num4++);//40 System.out.println(num4);//41 System.out.println("=============================================================="); //和賦值操作混合 int num5 = 50; int result1 = num5++; System.out.println(result1);//50 System.out.println(num5);//51 int num6 = 60; int reuslt2 = --num6; System.out.println(reuslt2);//59 System.out.println(num6);//59 System.out.println("=============================================================="); int x = 10; int y = 20; int result = --x + y++; System.out.println(result);//29 System.out.println(x);//9 System.out.println(y);//21 //30++; //隻有變量才能自增或自減，常量使用會(hui) 編譯報錯。 } }

賦值運算符

1.基本賦值運算符
就是=，代表把右邊的數據值賦值給左邊的變量
2.複合賦值運算符
+=： a += 5 相當於(yu) a = a + 5;
-=： a -= 5 相當於(yu) a = a - 5;
*=： a *= 5 相當於(yu) a = a * 5;
/=： a /= 5 相當於(yu) a = a / 5;
%=： a += 5 相當於(yu) a = a % 5;

注意事項：
1.隻有變量可以使用複合賦值運算，常量不可以使用。
2.複合賦值運算實際含有一個(ge) 隱式的數據類型轉換。

public class Demo07Operator{ public static void main(String[] args){ int a = 10; a += 5; System.out.println(a);//15 int b = 13; b %= 4; System.out.println(b);//1 //複合賦值運算中隱含了一個(ge) 強製類型轉換 byte x = 12; //x += 5; //相當於(yu) x = x + 5; // byte = byte + int ; //byte = int + int ; //byte = int ; //byte = (byte)int; x += 5; System.out.println(x);//17 } }

比較運算符

比較運算符： > , < , >= , <= , == ,!=;
注意事項：
1.比較運算符的結果一定是boolean類型。
2.如果進行多次判斷，不能像數學中連寫(xie) ，如1<x<3,這樣會(hui) 編譯報錯。

public class Demo08Operator{ public static void main(String[] args){ int x = 10; int y = 20; System.out.println(x > y);//false System.out.println(x < y);//true; System.out.println(x >= 100);//false System.out.println(x <= 10);//true; System.out.println(10 == 10);//true System.out.println(20 != 20);//false } }

邏輯運算符

與(yu) ：&&;
或：||;
非：!;

與(yu) 、或具有短路效果：就是根據左邊的表達式已經能夠判斷出結果，那麽(me) 後邊的表達式將不再運行，節省性能。

public class Demo09Logic{ public static void main(String[] args){ System.out.println(true && true);//true System.out.println(true && false);//false System.out.println(3 < 4 && 10 < 100);//true System.out.println(true || true);//true System.out.println(true || false);//true System.out.println(false || false);//false System.out.println(!true);//false System.out.println(!false);//true System.out.println("======================"); //短路效果： int a = 10; System.out.println(3 > 4 && ++a > 1);//false System.out.println(a);//10 int b = 20; System.out.println(3 < 4 || b++ > 1);//true System.out.println(b);//20 } }

三元運算符

格式：
數據類型變量名稱 = 條件判斷 ? 表達式A : 表達式B；

注意事項：
1.表達式A和表達式B必須同時滿足左邊的數據類型，否則編譯報錯。
2.三元運算符的結果必須被使用，要麽(me) 賦值，要麽(me) 打印等，不能獨立存在

public class Demo10Operator{ public static void main(String[] args){ int a = 10; int b = 20; int max = a > b ? a : b; System.out.println("最大值是：" + max);//20 //注意事項1： //int max = 3 > 4 ? 2.5 : 10;//錯誤寫(xie) 法，必須同時滿足左邊的int類型 //注意事項2： System.out.println(a > b ? a : b);//正確寫(xie) 法將會(hui) 打印20 //a > b ? a : b;錯誤寫(xie) 法，編譯報錯 } }

程序流程

順序結構

順序結構：程序由上至下運行。

# 選擇結構 #
1.單if語句

public class Demo02If{ public static void main(String[] args){ System.out.println("今天我準備去網吧"); int age = 17; if(age >= 18){ System.out.println("年齡滿18才能進入網吧"); } System.out.println("回家"); } }

2.if Else語句

public class Demo03IfElse{ public static void main(String[] args){ int age = 20; if(age >= 18){ System.out.println("可以進入網吧"); }else{ System.out.println("不能進入網吧"); } } }

3.if elseif語句

public class Demo04IfElseExt{ public static void main(String[] args){ int x = 15; int y; if(x >= 3){ y = 2*x+1; } else if (-1 < x && x < 3){ y = 2*x; } else { y = 2*x-1; } System.out.println("結果是"+ y); } }

4.標準的switch語句

public class Demo07Switch{ public static void main(String[] args){ int num = 4; 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("今天是星期四"); break; case 5: System.out.println("今天是星期五"); break; case 6: System.out.println("今天是星期六"); break; case 7: System.out.println("今天是星期七"); break; default: System.out.println("數據不合理"); break;//不寫(xie) 這個(ge) break不會(hui) 報錯，但是強烈建議寫(xie) 上。 } } }

switch case注意事項:
①case後麵的數值不能重複
②case後麵可以是基本類型也可以是引用類型：
基本類型：byte,short,char,int
引用類型: String,enum

public class Demo08SwitchNotice{ public static void main(String[] args){ int num = 3; switch(num){ case 2: System.out.println("BBB"); break; case 3: System.out.println("AAA"); case 1: System.out.println("CCC"); break; default: System.out.println("DDD"); break; } System.out.println("具有穿透功能的switch"); } }

循環結構

1.for循環

/* 循環結構： for循環 for(初始化語句①;條件判斷②；步進語句④){ 循環體(ti) ③ } */ public class Demo09For{ public static void main(String[] args){ for(int i=1;i<=100;i++){ System.out.println("我錯了！請原諒我把！"+i); } } }

2.while循環

/* while循環：標準格式： while(條件判斷){ 循環體(ti) } 擴展格式：初始化語句； while(條件判斷){ 循環體(ti) ；步進語句； } */ public class Demo10While{ public static void main(String[] args){ int i = 1; while(i<=10){ System.out.println("我錯了！"+ i ); i++; } } }

3.do-while循環

/* doWhile循環 do{ 循環體(ti) 步進語句 }while（條件判斷） dowhile循環一上來就先執行一次do裏麵的內(nei) 容，再進行條件判斷是否繼續循環 */ public class Demo11DoWhile{ public static void main(String[] args){ int i = 1; do{ System.out.println("起來吧，原諒你了"); i++; }while(i <= 10); } }

4.條件控製語句
break：
①在switch語句中使用，一旦執行，整個(ge) switch將被打斷
②在循環中使用，一旦執行，整個(ge) 循環被打斷

public class Demo13Break{ public static void main(String[] args){ for(int i=1;i<=10;i++){ if(i==4){ break; } System.out.println("hello"+i); } } }

continue：
在循環中使用，一旦執行，表示跳出當次循環，繼續下一次循環

public class Demo14Continue{ public static void main(String[] args){ for(int i = 1;i <= 10;i++){ if(i == 4){ continue; } System.out.println(i+"層到了"); } }

break和continue的區別：
break是打斷，終止整個(ge) 循環結構，執行break後將不再執行任何循環體(ti) 內(nei) 容。
continue是跳出當次循環，繼續下一次循環，執行continue後，循環還可以繼續。
5.死循環

public class Demo15DeadLoop{ public static void main(String[] args){ while(true){ System.out.println("I love Java!"); } //System.out.println("hello");這是錯誤寫(xie) 法，循環不結束，這句話不會(hui) 執行，會(hui) 編譯報錯 } }

6.循環嵌套

public class Demo16LoopHourAndMinute { public static void main(String[] args){ for(int hour = 0 ;hour < 24;hour++){ for(int minute = 1;minute < 60;minute++){ System.out.println( hour + "點" + minute + "分"); } } } }

方法

1.方法的定義(yi)
定義(yi) 格式：
public static void 方法名稱() {
方法體(ti)
}
調用格式：方法名稱();
注意事項：

方法定義的先後順序無所謂。
方法定義必須是挨著的，不能在一個方法的內部定義另外一個方法。
方法定義之後，自己不會執行的；如果希望執行，一定要進行方法的調用。

public class Demo01Method { public static void main(String[] args) { printMethod(); } public static void printMethod() { for (int j = 0; j < 5; j++) { for (int i = 0; i < 20; i++) { System.out.print("*"); } System.out.println(); } } }

2.方法
方法其實就是若幹語句的功能集合。

方法好比是一個(ge) 工廠。
蒙牛工廠原料：奶牛、飼料、水
產(chan) 出物：奶製品
鋼鐵工廠原料：鐵礦石、煤炭
產(chan) 出物：鋼鐵建材

參數（原料）：就是進入方法的數據。
返回值（產(chan) 出物）：就是從(cong) 方法中出來的數據。

定義(yi) 方法的完整格式：
修飾符返回值類型方法名稱(參數類型參數名稱, …) {
方法體(ti)
return 返回值;
}

修飾符：現階段的固定寫(xie) 法，public static
返回值類型：也就是方法最終產(chan) 生的數據結果是什麽(me) 類型
方法名稱：方法的名字，規則和變量一樣，小駝峰
參數類型：進入方法的數據是什麽(me) 類型
參數名稱：進入方法的數據對應的變量名稱
PS：參數如果有多個(ge) ，使用逗號進行分隔
方法體(ti) ：方法需要做的事情，若幹行代碼
return：兩(liang) 個(ge) 作用，第一停止當前方法，第二將後麵的返回值還給調用處
返回值：也就是方法執行後最終產(chan) 生的數據結果

注意：return後麵的“返回值”，必須和方法名稱前麵的“返回值類型”，保持對應。

定義(yi) 一個(ge) 兩(liang) 個(ge) int數字相加的方法。三要素：
返回值類型：int
方法名稱：sum
參數列表：int a, int b

方法的三種調用格式。

單獨調用：方法名稱(參數);
打印調用：System.out.println(方法名稱(參數));
賦值調用：數據類型變量名稱 = 方法名稱(參數);

注意：此前學習(xi) 的方法，返回值類型固定寫(xie) 為(wei) void，這種方法隻能夠單獨調用，不能進行打印調用或者賦值調用。

public class Demo02MethodDefine { public static void main(String[] args) { // 單獨調用 sum(10, 20); System.out.println("==========="); // 打印調用 System.out.println(sum(10, 20)); // 30 System.out.println("==========="); // 賦值調用 int number = sum(15, 25); number += 100; System.out.println("變量的值：" + number); // 140 } public static int sum(int a, int b) { System.out.println("方法執行啦！"); int result = a + b; return result; } }

3.方法的參數
有參數：小括號當中有內(nei) 容，當一個(ge) 方法需要一些數據條件，才能完成任務的時候，就是有參數。
例如兩(liang) 個(ge) 數字相加，必須知道兩(liang) 個(ge) 數字是各自多少，才能相加。

無參數：小括號當中留空。一個(ge) 方法不需要任何數據條件，自己就能獨立完成任務，就是無參數。
例如定義(yi) 一個(ge) 方法，打印固定10次HelloWorld。

public class Demo03MethodParam { public static void main(String[] args) { method1(10, 20); System.out.println("=============="); method2(); } // 兩(liang) 個(ge) 數字相乘，做乘法，必須知道兩(liang) 個(ge) 數字各自是多少，否則無法進行計算 // 有參數 public static void method1(int a, int b) { int result = a * b; System.out.println("結果是：" + result); } // 例如打印輸出固定10次文本字符串 public static void method2() { for (int i = 0; i < 10; i++) { System.out.println("Hello, World!" + i); } } }

4.return語句

/* 題目要求：定義(yi) 一個(ge) 方法，用來【求出】兩(liang) 個(ge) 數字之和。（你幫我算，算完之後把結果告訴我。）題目變形：定義(yi) 一個(ge) 方法，用來【打印】兩(liang) 個(ge) 數字之和。（你來計算，算完之後你自己負責顯示結果，不用告訴我。）注意事項：對於(yu) 有返回值的方法，可以使用單獨調用、打印調用或者賦值調用。但是對於(yu) 無返回值的方法，隻能使用單獨調用，不能使用打印調用或者賦值調用。 */ public class Demo04MethodReturn { public static void main(String[] args) { // 我是main方法，我來調用你。 // 我調用你，你來幫我計算一下，算完了之後，把結果告訴我的num變量 int num = getSum(10, 20); System.out.println("返回值是：" + num); System.out.println("=============="); printSum(100, 200); System.out.println("=============="); System.out.println(getSum(2, 3)); // 正確寫(xie) 法 getSum(3, 5); // 正確寫(xie) 法，但是返回值沒有用到 System.out.println("=============="); // 對於(yu) void沒有返回值的方法，隻能單獨，不能打印或者賦值 // System.out.println(printSum(2, 3)); // 錯誤寫(xie) 法！ // System.out.println(void); // int num2 = printSum(10, 20); // 錯誤寫(xie) 法！ // int num3 = void; // void num4 = void; } // 我是一個(ge) 方法，我負責兩(liang) 個(ge) 數字相加。 // 我有返回值int，誰調用我，我就把計算結果告訴誰 public static int getSum(int a, int b) { int result = a + b; return result; } // 我是一個(ge) 方法，我負責兩(liang) 個(ge) 數字相加。 // 我沒有返回值，不會(hui) 把結果告訴任何人，而是我自己進行打印輸出。 public static void printSum(int a, int b) { int result = a + b; System.out.println("結果是：" + result); } }

5.使用方法時注意事項

方法應該定義在類當中，但是不能在方法當中再定義方法。不能嵌套。
方法定義的前後順序無所謂。
方法定義之後不會執行，如果希望執行，一定要調用：單獨調用、打印調用、賦值調用。
如果方法有返回值，那麽必須寫上“return 返回值;”，不能沒有。
return後麵的返回值數據，必須和方法的返回值類型，對應起來。
對於一個void沒有返回值的方法，不能寫return後麵的返回值，隻能寫return自己。
對於void方法當中最後一行的return可以省略不寫。
一個方法當中可以有多個return語句，但是必須保證同時隻有一個會被執行到，兩個return不能連寫。

public class Demo04MethodNotice { public static int method1() { return 10; } public static void method2() { // return 10; // 錯誤的寫(xie) 法！方法沒有返回值，return後麵就不能寫(xie) 返回值。 return; // 沒有返回值，隻是結束方法的執行而已。 } public static void method3() { System.out.println("AAA"); System.out.println("BBB"); // return; // 最後一行的return可以省略不寫(xie) 。 } public static int getMax(int a, int b) { /*int max; if (a > b) { max = a; } else { max = b; } return max;*/ if (a > b) { return a; } else { return b; } } }

方法的重載

什麽(me) 是方法的重載？
多個(ge) 方法的名稱一樣，但是數據列表不一樣。

方法的重載和下列因素有關(guan) ：
1.和參數個(ge) 數有關(guan) 。
2.和多種參數的順序有關(guan) 。
3.和參數類型有關(guan) 。

方法的重載和下列因數無關(guan) ：
1.和參數的名稱無關(guan) 。
2.和返回值類型無關(guan) 。

public class Demo01MethodOverload { public static void main(String[] args) { System.out.println(sum(10,20)); System.out.println(sum(10,20,30)); System.out.println(sum(10,20,30,40)); } public static int sum(int a,int b){ return a + b; } //與(yu) 參數的名稱無關(guan) // public static int sum(int x , int y){ // return x + y; // } //與(yu) 返回值類型無關(guan) // public static double sum(double a , double b){ // return a + b; // } //與(yu) 參數類型有關(guan) public static int sum(double a ,double b){ return (int)(a + b); } //與(yu) 多個(ge) 不同類型參數的順序有關(guan) public static int sum(double a,int b){ return (int)(a + b); } public static int sum(int a , double b){ return (int)(a + b); } public static int sum(int a,int b,int c){ return a + b + c; } public static int sum(int a,int b,int c,int d){ return a + b + c + d; } }

數組

什麽(me) 是數組？
數組是一個(ge) 容器，用來存儲(chu) 同一類型的數據。

數組的特點：
1.數組是一種引用類型數據。
2.數組中的數據是屬於(yu) 同一種類型。
3.數組的長度不可改變。

定義(yi) 一個(ge) 數組有兩(liang) 種常見的方式：
1.動態初始化數組(指定長度):
數據類型[] 數組名稱 = new 數據類型[數組長度];

public class Demo01Array { public static void main(String[] args) { //創建一個(ge) 長度為(wei) 10的int類型數組 int[] arr1 = new int[10]; //創建一個(ge) 長度為(wei) 20的double類型數組 double[] arr2 = new double[20]; //創建一個(ge) 長度為(wei) 5的String類型數組 String[] arr3 = new String[5]; } }

2.靜態初始化數組(指定內(nei) 容):
數據類型[] 數組名稱 = new 數據類型[]{元素1，元素2，…};

public class Demo02Array { public static void main(String[] args) { //創建一個(ge) 數組，是int類型數據，裏麵裝 5,10,15 int[] arr1 = new int[]{ 5 , 10 , 15}; //創建一個(ge) 數組，裏麵裝String類型數據，裏麵裝"Hello" ,"World" ,"Java" String[] arr2 = new String[]{"Hello" , "World" , "Java"}; } }

靜態初始化數組的省略格式：
數據類型[] 數組名稱 = {元素1，元素2，…};

public class Demo03Array { public static void main(String[] args) { //省略格式創建一個(ge) 給int數組，使用省略格式，裏麵是5,6,7 int[] arr1 = {5,6,7}; //靜態初始化的標準格式可以拆分為(wei) 兩(liang) 個(ge) 步驟 int[] arr2; arr2 = new int[]{5,6,7}; //動態初始化也可以拆分為(wei) 兩(liang) 個(ge) 步驟 int[] arr3; arr3 = new int[10]; //靜態初始化一旦使用省略格式，不能再拆分為(wei) 兩(liang) 個(ge) 步驟 // int[] arr4; // arr4 = {5,6,7};//編譯報錯，這種格式不被允許 } }

Java中內(nei) 存劃分為(wei) 5個(ge) 部分：
1.棧(Stack):存儲(chu) 局部變量，方法的運行在棧中。
2.堆(Heap):凡是new出來的東(dong) 西，都在堆中。
3.方法區：存儲(chu) .class文件中的信息，包含方法信息。
4.本地方法棧：和操作係統有關(guan) 。
5.寄存器：和CPU有關(guan) 。

Java中數組的內(nei) 存圖：
1.一個(ge) 數組的內(nei) 存圖：

public class Demo01ArrayOne { public static void main(String[] args) { int[] arr1 = new int[3]; System.out.println(arr1[0]); System.out.println(arr1[1]); System.out.println(arr1[2]); arr1[1] = 10; arr1[2] = 20; System.out.println(arr1[0]); System.out.println(arr1[1]); System.out.println(arr1[2]); } }

2.兩(liang) 個(ge) 數組的內(nei) 存圖：

public class Demo02ArrayTwo { public static void main(String[] args) { int[] arrA = new int[3]; System.out.println(arrA[0]); System.out.println(arrA[1]); System.out.println(arrA[2]); arrA[1] = 10; arrA[2] = 20; System.out.println(arrA[0]); System.out.println(arrA[1]); System.out.println(arrA[2]); System.out.println("=================="); int[] arrB = new int[3]; System.out.println(arrB[0]); System.out.println(arrB[1]); System.out.println(arrB[2]); arrB[1] = 10; arrB[2] = 20; System.out.println(arrB[0]); System.out.println(arrB[1]); System.out.println(arrB[2]); } }

3.兩(liang) 個(ge) 引用指向同一個(ge) 數組的內(nei) 存圖：

public class Demo03ArraySame { public static void main(String[] args) { int[] arrA = new int[3]; System.out.println(arrA[0]);//0 System.out.println(arrA[1]);//0 System.out.println(arrA[2]);//0 arrA[1] = 10; arrA[2] = 20; System.out.println(arrA[0]);//0 System.out.println(arrA[1]);//10 System.out.println(arrA[2]);//20 System.out.println("=============="); int[] arrB = arrA; System.out.println(arrB[0]);//0 System.out.println(arrB[1]);//10 System.out.println(arrB[2]);//20 arrB[1] = 100; arrB[2] = 200; System.out.println(arrB[0]);//0 System.out.println(arrB[1]);//100 System.out.println(arrB[2]);//200 System.out.println("=============="); } }

數組的兩(liang) 種常見問題：
1.數組索引越界異常：訪問數組元素時，索引編號不存在，那麽(me) 將會(hui) 發生數據索引越界異常。ArrayIdexOutOfBoundsException
原因：索引值不正確。
解決(jue) 辦法：修改索引值。

public class Demo01ArrayIndexOutOfBoundsException { public static void main(String[] args) { int[] arr = {15, 25, 35}; System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); //錯誤寫(xie) 法，會(hui) 引發數組索引越界異常 System.out.println(arr[3]); } }

2.空指針異常：如果沒有對數組進行初始化，訪問元素的時候，會(hui) 產(chan) 生空指針異常。NullPointerException
原因：沒有對數組進行初始化，數組是null值。
解決(jue) 辦法：對數組進行初始化。

public class Demo02NullPointerException { public static void main(String[] args) { int[] arr = null; //arr = new int[3]; System.out.println(arr[0]); } }

數組的長度：
獲取數組的長度通過其length屬性，即可獲得。
int length = arr.length;
注意事項：
數組一旦創建，其長度是不可變的。

public class Demo03ArrayLength { public static void main(String[] args) { //創建一個(ge) 長度為(wei) 3的數組 int[] arr = new int[3]; System.out.println(arr.length); //這裏並不是數組的長度由3變成5，而是又創建了一個(ge) // 長度為(wei) 5的數組，變量arr的地址值發生了改變。 arr = new int[5]; System.out.println(arr.length); } }

遍曆數組：對數組中每一個(ge) 元素進行逐個(ge) 處理。

public class Demo04Array { public static void main(String[] args) { int[] arr = {2,3,4,5,6,7,8,9,14,15,123,144,234,56,43,21,78,82,22}; for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } }

練習(xi) ：
1.求出數組中的最大值：

public class Demo05ArrayMax { public static void main(String[] args) { int[] arr = {2,3,4,5,6,7,8,9,14,15,123,144,234,56,43,21,78,82,22}; int max = arr[0]; for (int i = 1; i < arr.length; i++) { if(arr[i]>max){ max = arr[i]; } } System.out.println("最大值是:"+ max ); } }

2.求出數組中的最小值：

public class Demo06ArrayMin { public static void main(String[] args) { int[] arr = {2,3,4,5,6,7,8,9,14,15,123,144,234,56,43,21,78,82,22}; int min = arr[0]; for (int i = 1; i < arr.length; i++) { if(arr[i]<min){ min = arr[i]; } } System.out.println("最小值是:" + min ); } }

3.數組的反轉：

/* * 數組的反轉： * 本來的樣子：[1,2,3,4] * 反轉的樣子:[4,3,2,1] * 不能使用新的數組 * * 思路： * 1.數組的反轉是兩(liang) 個(ge) 對稱位置的數據交換 * 2.需要兩(liang) 個(ge) 索引，min和max * 3.需要一個(ge) 臨(lin) 時變量 * 4.條件判斷，當min小於(yu) max時才交換，否則不交換 * */ public class Demo07ArrayReverse { public static void main(String[] args) { int[] arr = {2,3,4,5,6,7,8,9,14,15,123,144,234,56,43,21,78,82,22}; //遍曆原來的數組 for (int i = 0; i < arr.length; i++) { System.out.print(arr[i]+" "); } System.out.println(); //反轉 for (int min=0,max = arr.length-1; min < max ; min++ , max-- ){ int temp = arr[min]; arr[min] = arr[max]; arr[max] = temp; } //遍曆新的數組 for (int i = 0; i < arr.length; i++) { System.out.print(arr[i]+" "); } } }

數組也可以作為(wei) 方法的參數：
當調用方法的時候，向小括號傳(chuan) 參，事實上傳(chuan) 遞的是數組在堆內(nei) 存中的地址值。
數組也可以作為(wei) 方法的返回值：
其實返回的也是數組在堆內(nei) 存中的地址值。

public class Demo01ArrayParam {
    public static void main(String[] args) {
        int[] arr = {10,20,30};
        myPrint(arr);
        int[] result = sumAndAvg(arr);
        System.out.println(result);
        myPrint(result);
    }
    public static void myPrint(int[] arr){
        //事實上傳遞的是地址值
        System.out.println(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    public static int[] sumAndAvg(int[] arr){
        int[] arr1 = null;
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        int avg = sum / arr.length;
        arr1 = new int[]{sum , avg};
        return arr1;
    }
}

18luck网站

JAVA語法程序匯總_Java基礎語法總結