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

Java基礎語法

計算機基礎

1.什么是二進制？

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

2.什么是字節？

我們知道計算機中的數據都是由1或者0組成，每個0或1都是一個bit，每8個bit就是一個字節(byte）。
字節是數據存儲的最小單位。
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應用，那么只需要安裝JRE即可。

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

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

關鍵字和標識符

關鍵字的特點：

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

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

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

常量和變量

常量

什么是常量？
常量就是在程序運行期間，不會改變的量。

常量的分類
字符串常量：凡是用雙引號括起來的都是字符串常量，例如：“abc”,“110”,“Hello”…
字符常量：凡是用單引號括起來的單個字符，就叫字符常量。例如：‘A’,‘a’,‘1’,‘張’
整型常量：直接寫上的數字，沒有小數點。例如：123,200，-23
浮點型常量：直接寫上的數字，有小數點。例如：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('');單引號中間有且僅有一個字符，沒有不行，編譯出錯
  // 布爾常量 
  System.out.println(true);
  System.out.println(false);
  //空常量 null,不能直接打印
 }
}

數據類型

數據類型分為兩類：

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

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

基本數據類型注意事項：
1.字符串不是基本數據類型，而是引用類型。
2.浮點型可能是一個近似值，而不是精確值。
3.數據范圍不一定與字節數相關，例如float的范圍比long要廣，但是它只占4個字節。
4.浮點數默認是double類型，要使用float類型，需要加上后綴F/f，但是建議使用F。
5.整數默認為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類型，數據類型不一致，會發生數據轉換，
  //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
 }
}

變量

什么是變量？
就是在程序運行期間，會發生改變的量。

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

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會產生錯誤。
  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);
  //可以這么使用，但是不建議。
  int a = 10,b = 20,c = 30;
  System.out.println(a);
  System.out.println(b);
  System.out.println(c);
 }
}

數據類型轉換

什么是數據類型轉換？
當數據類型不一樣時，就會發生數據類型轉換。

數據類型轉換的分類：

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

public class Demo01DataType{
 public static void main(String[] args){
  System.out.println(1024);//默認是int類型
  System.out.println(3.14);//默認是double類型
  //左邊是long類型，右邊是int類型，數據類型不一致，會發生數據轉換，
  //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
 }
}

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

注意事項：

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

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

ASCII碼表

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

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
 }
}

運算符

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

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

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

public class Demo04Operator{
 public static void main(String[] args){
  System.out.println(20+30);//50
  int a = 10;
  int b = 20;
  //會先計算表達式的值，再進行打印
  System.out.println(a-b);//-10
  System.out.println(a*10);//100
  //除法，只看商
  int result1 = 10/3;
  System.out.println(result1);//3
  //如果想要獲得余數，用取模運算
  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.單獨使用：++在前和在后沒有任何區別，獨自形成一個步驟（前提是不與任何其他操作混合）
2.混合使用：當混合使用時，++在前和在后有【重大區別】：
a.++在前時，變量立刻+1，然后再參與其他運算【先加后用】
b.++在后時，變量首先按照原來的值參與其他運算，然后再+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("==============================================================");
  //混合使用，例如與打印操作混合
  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++; //只有變量才能自增或自減，常量使用會編譯報錯。
 }
}

賦值運算符

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

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

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
  //復合賦值運算中隱含了一個強制類型轉換
  byte x = 12;
  //x += 5; 
  //相當于 x = x + 5;
  // byte  = byte + int ;
  //byte =  int + int ;
  //byte = int ;
  //byte = (byte)int;
  x += 5;
  System.out.println(x);//17
 }
}

比較運算符

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

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
 }
}

邏輯運算符

與：&&;
或：||;
非：!;

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

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.三元運算符的結果必須被使用，要么賦值，要么打印等，不能獨立存在

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;//錯誤寫法，必須同時滿足左邊的int類型
  //注意事項2：
  System.out.println(a > b ? a : b);//正確寫法 將會打印20
  //a > b ? a : b;錯誤寫法，編譯報錯
 }
}

程序流程

順序結構

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

#### 選擇結構 ####
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;//不寫這個break不會報錯，但是強烈建議寫上。
  }
 }
}

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

2.while循環

/*
while循環：
標準格式：
while(條件判斷){
 循環體
}
擴展格式：
初始化語句；
while(條件判斷){
 循環體；
 步進語句；
}
*/
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{
   循環體
   步進語句
  }while（條件判斷）
  dowhile循環一上來就先執行一次do里面的內容，再進行條件判斷是否繼續循環
*/
public class Demo11DoWhile{
 public static void main(String[] args){
  int i = 1;
  do{
   System.out.println("起來吧，原諒你了");
   i++;
  }while(i <= 10);
 }
}

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

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是打斷，終止整個循環結構，執行break后將不再執行任何循環體內容。
continue是跳出當次循環，繼續下一次循環，執行continue后，循環還可以繼續。
5.死循環

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

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.方法的定義
定義格式：
public static void 方法名稱() {
方法體
}
調用格式：方法名稱();
注意事項：

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

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.方法
方法其實就是若干語句的功能集合。

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

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

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

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

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

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

方法的三種調用格式。

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

注意：此前學習的方法，返回值類型固定寫為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.方法的參數
有參數：小括號當中有內容，當一個方法需要一些數據條件，才能完成任務的時候，就是有參數。
例如兩個數字相加，必須知道兩個數字是各自多少，才能相加。

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

public class Demo03MethodParam {
    public static void main(String[] args) {
        method1(10, 20);
        System.out.println("==============");
        method2();
    }
    // 兩個數字相乘，做乘法，必須知道兩個數字各自是多少，否則無法進行計算
    // 有參數
    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語句

/*
題目要求：定義一個方法，用來【求出】兩個數字之和。（你幫我算，算完之后把結果告訴我。）
題目變形：定義一個方法，用來【打印】兩個數字之和。（你來計算，算完之后你自己負責顯示結果，不用告訴我。）
注意事項：
對于有返回值的方法，可以使用單獨調用、打印調用或者賦值調用。
但是對于無返回值的方法，只能使用單獨調用，不能使用打印調用或者賦值調用。
 */
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)); // 正確寫法
        getSum(3, 5); // 正確寫法，但是返回值沒有用到
        System.out.println("==============");
        // 對于void沒有返回值的方法，只能單獨，不能打印或者賦值
//        System.out.println(printSum(2, 3)); // 錯誤寫法！
//        System.out.println(void);
//        int num2 = printSum(10, 20); // 錯誤寫法！
//        int num3 = void;
//        void num4 = void;
    }
    // 我是一個方法，我負責兩個數字相加。
    // 我有返回值int，誰調用我，我就把計算結果告訴誰
    public static int getSum(int a, int b) {
        int result = a + b;
        return result;
    }
    // 我是一個方法，我負責兩個數字相加。
    // 我沒有返回值，不會把結果告訴任何人，而是我自己進行打印輸出。
    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; // 錯誤的寫法！方法沒有返回值，return后面就不能寫返回值。
        return; // 沒有返回值，只是結束方法的執行而已。
    }
    public static void method3() {
        System.out.println("AAA");
        System.out.println("BBB");
//        return; // 最后一行的return可以省略不寫。
    }
    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;
        }
    }
}

方法的重載

什么是方法的重載？
多個方法的名稱一樣，但是數據列表不一樣。

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

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

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;
    }
    //與參數的名稱無關
//    public static int sum(int x , int y){
//        return x + y;
//    }
    //與返回值類型無關
//    public static double sum(double a , double b){
//        return a + b;
//    }
    //與參數類型有關
    public static int sum(double a ,double b){
        return (int)(a + b);
    }
    //與多個不同類型參數的順序有關
    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;
    }
}

數組

什么是數組？
數組是一個容器，用來存儲同一類型的數據。

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

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

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

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

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

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

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

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

Java中數組的內存圖：
1.一個數組的內存圖：

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.兩個數組的內存圖：

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.兩個引用指向同一個數組的內存圖：

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("==============");
    }
}

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

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]);
        //錯誤寫法，會引發數組索引越界異常
        System.out.println(arr[3]);
    }
}

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

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) {
        //創建一個長度為3的數組
        int[] arr = new int[3];
        System.out.println(arr.length);
        //這里并不是數組的長度由3變成5，而是又創建了一個
        // 長度為5的數組，變量arr的地址值發生了改變。
        arr = new int[5];
        System.out.println(arr.length);
    }
}

遍歷數組：對數組中每一個元素進行逐個處理。

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]);
        }
    }
}

練習：
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.數組的反轉是兩個對稱位置的數據交換
* 2.需要兩個索引，min和max
* 3.需要一個臨時變量
* 4.條件判斷，當min小于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]+" ");
        }
    }
}

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

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;
    }
}

電子開發網

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

Java基礎語法

計算機基礎

1.什么是二進制？

2.什么是字節？

3.命令提示符

Java語言基礎

JRE和JDK、JVM

關鍵字和標識符

常量和變量

常量

數據類型

變量

數據類型轉換

ASCII碼表

運算符

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

自增、自減運算符

賦值運算符

比較運算符

邏輯運算符

三元運算符

程序流程

順序結構

循環結構

方法

方法的重載

數組

Tags：語法,JAVA,基礎語法

電子開發網

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

Java基礎語法

計算機基礎

1.什么是二進制？

2.什么是字節？

3.命令提示符

Java語言基礎

JRE和JDK、JVM

關鍵字和標識符

常量和變量

常量

數據類型

變量

數據類型轉換

ASCII碼表

運算符

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

自增、自減運算符

賦值運算符

比較運算符

邏輯運算符

三元運算符

程序流程

順序結構

循環結構

方法

方法的重載

數組

Tags：語法,JAVA,基礎語法

1.什么是二進制？

JRE和JDK、JVM

自增、自減運算符