Java基礎(chǔ)語法
 計算機基礎(chǔ)
1.什么是二進(jìn)制？
2.什么是字節(jié)？
3.命令提示符
 Java語言基礎(chǔ)
JRE和JDK、JVM
關(guān)鍵字和標(biāo)識符
 常量和變量
 數(shù)據(jù)類型轉(zhuǎn)換
 運算符
 程序流程
 方法

Java基礎(chǔ)語法

計算機基礎(chǔ)

1.什么是二進(jìn)制？

二進(jìn)制數(shù)只包含0和1，每一個0或者1都是一個bit（位）。
我們常用的十進(jìn)制如何轉(zhuǎn)換成二進(jìn)制：

2.什么是字節(jié)？

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

3.命令提示符

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

Java語言基礎(chǔ)

JRE和JDK、JVM

JRE(Java Runtime Enviroment),Java運行環(huán)境，如果只是需要在該計算機上運行Java應(yīng)用，那么只需要安裝JRE即可。

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

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

關(guān)鍵字和標(biāo)識符

關(guān)鍵字的特點：

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

標(biāo)識符：自己命名的類名，方法名等。
命名規(guī)則：

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

常量和變量

常量

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

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

public class Demo01Const{
 public static void main(String[] args){
  // 字符串常量 
  System.out.println("ABC");
  System.out.println("");
  System.out.println("XYZ");
  // 整數(shù)常量
  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,不能直接打印
 }
}

數(shù)據(jù)類型

數(shù)據(jù)類型分為兩類：

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

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

基本數(shù)據(jù)類型注意事項：
1.字符串不是基本數(shù)據(jù)類型，而是引用類型。
2.浮點型可能是一個近似值，而不是精確值。
3.數(shù)據(jù)范圍不一定與字節(jié)數(shù)相關(guān)，例如float的范圍比long要廣，但是它只占4個字節(jié)。
4.浮點數(shù)默認(rèn)是double類型，要使用float類型，需要加上后綴F/f，但是建議使用F。
5.整數(shù)默認(rèn)為int類型，要使用long類型，需要加上后綴L/l，但是建議使用L。

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

變量

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

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

public class Demo02Variable{
 public static void main(String[] args){
  //使用格式①創(chuàng)建變量
  int num1;
  num1=1;
  System.out.println(num1);
  //改變變量當(dāng)中的值
  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
 }
}

使用變量的注意事項

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

public class Demo03VariableNotice{
 public static void main(String[] args){
  int num1 = 10;
  System.out.println(num1);
  //int num1 = 20;錯誤，變量名不能重復(fù)。
  float num2 = 3.14F;//如果不加F會產(chǎn)生錯誤。
  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);
 }
}

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

什么是數(shù)據(jù)類型轉(zhuǎn)換？
當(dāng)數(shù)據(jù)類型不一樣時，就會發(fā)生數(shù)據(jù)類型轉(zhuǎn)換。

數(shù)據(jù)類型轉(zhuǎn)換的分類：

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

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

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

注意事項：

強制類型轉(zhuǎn)換有可能導(dǎo)致精度丟失、數(shù)據(jù)溢出等。
byte、short、char類型都可以進(jìn)行數(shù)學(xué)運算。
byte、short、char類型在進(jìn)行數(shù)學(xué)運算時，都被提升成了int類型，再進(jìn)行計算。
boolean類型不能進(jìn)行數(shù)據(jù)轉(zhuǎn)換。

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

ASCII碼表

什么是ASCII碼表？
ASCII：American Standard Code of Information Inchange 美國信息交換標(biāo)準(zhǔn)代碼
還有Unicode表，就是數(shù)字和字符的對照關(guān)系表。

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類型，左右不一致，發(fā)生數(shù)據(jù)類型轉(zhuǎn)換
  //char---->int 范圍小向范圍大轉(zhuǎn)換，自動轉(zhuǎn)換，不需要強制類型轉(zhuǎn)換
  int num = 'c';
  System.out.println(num);//99
  int ch3 = '中';
  System.out.println(ch3);//20013
 }
}

運算符

什么是運算符？
就是進(jìn)行特定操作的符號。
什么是表達(dá)式？
就是用運算符連接起來的式子。

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

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

public class Demo04Operator{
 public static void main(String[] args){
  System.out.println(20+30);//50
  int a = 10;
  int b = 20;
  //會先計算表達(dá)式的值，再進(jìn)行打印
  System.out.println(a-b);//-10
  System.out.println(a*10);//100
  //除法，只看商
  int result1 = 10/3;
  System.out.println(result1);//3
  //如果想要獲得余數(shù)，用取模運算
  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類型
用于連接字符串（注意事項：任何數(shù)據(jù)類型和字符串相連接，都會變成字符串)

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++。
使用區(qū)別：
1.單獨使用：++在前和在后沒有任何區(qū)別，獨自形成一個步驟（前提是不與任何其他操作混合）
2.混合使用：當(dāng)混合使用時，++在前和在后有【重大區(qū)別】：
a.++在前時，變量立刻+1，然后再參與其他運算【先加后用】
b.++在后時，變量首先按照原來的值參與其他運算，然后再+1 【先用后加】
注意事項：只有是變量才能使用自增、自減符號，常量無法使用。

public class Demo06Operator{
 public static void main(String[] args){
  //單獨使用的情況，沒有區(qū)別
  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.基本賦值運算符
就是=，代表把右邊的數(shù)據(jù)值賦值給左邊的變量
2.復(fù)合賦值運算符
+=： a += 5 相當(dāng)于 a = a + 5;
-=： a -= 5 相當(dāng)于 a = a - 5;
*=： a *= 5 相當(dāng)于 a = a * 5;
/=： a /= 5 相當(dāng)于 a = a / 5;
%=： a += 5 相當(dāng)于 a = a % 5;

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

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

比較運算符

比較運算符： > , < , >= , <= , == ,!=;
注意事項：
1.比較運算符的結(jié)果一定是boolean類型。
2.如果進(jìn)行多次判斷，不能像數(shù)學(xué)中連寫，如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
 }
}

邏輯運算符

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

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

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

三元運算符

格式：
數(shù)據(jù)類型變量名稱 = 條件判斷 ? 表達(dá)式A : 表達(dá)式B；

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

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;錯誤寫法，編譯報錯
 }
}

程序流程

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

順序結(jié)構(gòu)：程序由上至下運行。

#### 選擇結(jié)構(gòu) ####
1.單if語句

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

2.if Else語句

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

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("結(jié)果是"+ y);
 }
}

4.標(biāo)準(zhǔn)的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("數(shù)據(jù)不合理");
    break;//不寫這個break不會報錯，但是強烈建議寫上。
  }
 }
}

switch case注意事項:
①case后面的數(shù)值不能重復(fù)
②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");
 }
}

循環(huán)結(jié)構(gòu)

1.for循環(huán)

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

2.while循環(huán)

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

3.do-while循環(huán)

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

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

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：
在循環(huán)中使用，一旦執(zhí)行，表示跳出當(dāng)次循環(huán)，繼續(xù)下一次循環(huán)

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的區(qū)別：
break是打斷，終止整個循環(huán)結(jié)構(gòu)，執(zhí)行break后將不再執(zhí)行任何循環(huán)體內(nèi)容。
continue是跳出當(dāng)次循環(huán)，繼續(xù)下一次循環(huán)，執(zhí)行continue后，循環(huán)還可以繼續(xù)。
5.死循環(huán)

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

6.循環(huán)嵌套

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 方法名稱() {
方法體
}
調(diào)用格式：方法名稱();
注意事項：

方法定義的先后順序無所謂。
方法定義必須是挨著的，不能在一個方法的內(nèi)部定義另外一個方法。
方法定義之后，自己不會執(zhí)行的；如果希望執(zhí)行，一定要進(jìn)行方法的調(diào)用。

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

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

參數(shù)（原料）：就是進(jìn)入方法的數(shù)據(jù)。
返回值（產(chǎn)出物）：就是從方法中出來的數(shù)據(jù)。

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

修飾符：現(xiàn)階段的固定寫法，public static
返回值類型：也就是方法最終產(chǎn)生的數(shù)據(jù)結(jié)果是什么類型
方法名稱：方法的名字，規(guī)則和變量一樣，小駝峰
參數(shù)類型：進(jìn)入方法的數(shù)據(jù)是什么類型
參數(shù)名稱：進(jìn)入方法的數(shù)據(jù)對應(yīng)的變量名稱
PS：參數(shù)如果有多個，使用逗號進(jìn)行分隔
方法體：方法需要做的事情，若干行代碼
return：兩個作用，第一停止當(dāng)前方法，第二將后面的返回值還給調(diào)用處
返回值：也就是方法執(zhí)行后最終產(chǎn)生的數(shù)據(jù)結(jié)果

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

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

方法的三種調(diào)用格式。

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

注意：此前學(xué)習(xí)的方法，返回值類型固定寫為void，這種方法只能夠單獨調(diào)用，不能進(jìn)行打印調(diào)用或者賦值調(diào)用。

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

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

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

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

4.return語句

/*
題目要求：定義一個方法，用來【求出】兩個數(shù)字之和。（你幫我算，算完之后把結(jié)果告訴我。）
題目變形：定義一個方法，用來【打印】兩個數(shù)字之和。（你來計算，算完之后你自己負(fù)責(zé)顯示結(jié)果，不用告訴我。）
注意事項：
對于有返回值的方法，可以使用單獨調(diào)用、打印調(diào)用或者賦值調(diào)用。
但是對于無返回值的方法，只能使用單獨調(diào)用，不能使用打印調(diào)用或者賦值調(diào)用。
 */
public class Demo04MethodReturn {
    public static void main(String[] args) {
        // 我是main方法，我來調(diào)用你。
        // 我調(diào)用你，你來幫我計算一下，算完了之后，把結(jié)果告訴我的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;
    }
    // 我是一個方法，我負(fù)責(zé)兩個數(shù)字相加。
    // 我有返回值int，誰調(diào)用我，我就把計算結(jié)果告訴誰
    public static int getSum(int a, int b) {
        int result = a + b;
        return result;
    }
    // 我是一個方法，我負(fù)責(zé)兩個數(shù)字相加。
    // 我沒有返回值，不會把結(jié)果告訴任何人，而是我自己進(jìn)行打印輸出。
    public static void printSum(int a, int b) {
        int result = a + b;
        System.out.println("結(jié)果是：" + result);
    }
}

5.使用方法時注意事項

方法應(yīng)該定義在類當(dāng)中，但是不能在方法當(dāng)中再定義方法。不能嵌套。
方法定義的前后順序無所謂。
方法定義之后不會執(zhí)行，如果希望執(zhí)行，一定要調(diào)用：單獨調(diào)用、打印調(diào)用、賦值調(diào)用。
如果方法有返回值，那么必須寫上“return 返回值;”，不能沒有。
return后面的返回值數(shù)據(jù)，必須和方法的返回值類型，對應(yīng)起來。
對于一個void沒有返回值的方法，不能寫return后面的返回值，只能寫return自己。
對于void方法當(dāng)中最后一行的return可以省略不寫。
一個方法當(dāng)中可以有多個return語句，但是必須保證同時只有一個會被執(zhí)行到，兩個return不能連寫。

public class Demo04MethodNotice {
    public static int method1() {
        return 10;
    }
    public static void method2() {
//        return 10; // 錯誤的寫法！方法沒有返回值，return后面就不能寫返回值。
        return; // 沒有返回值，只是結(jié)束方法的執(zhí)行而已。
    }
    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;
        }
    }
}

方法的重載

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

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

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

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

數(shù)組

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

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

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

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

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

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

靜態(tài)初始化數(shù)組的省略格式：
數(shù)據(jù)類型[] 數(shù)組名稱 = {元素1，元素2，…};

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

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

Java中數(shù)組的內(nèi)存圖：
1.一個數(shù)組的內(nèi)存圖：

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.兩個數(shù)組的內(nèi)存圖：

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.兩個引用指向同一個數(shù)組的內(nèi)存圖：

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

數(shù)組的兩種常見問題：
1.數(shù)組索引越界異常：訪問數(shù)組元素時，索引編號不存在，那么將會發(fā)生數(shù)據(jù)索引越界異常。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]);
        //錯誤寫法，會引發(fā)數(shù)組索引越界異常
        System.out.println(arr[3]);
    }
}

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

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

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

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

遍歷數(shù)組：對數(shù)組中每一個元素進(jìn)行逐個處理。

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

練習(xí)：
1.求出數(shù)組中的最大值：

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.求出數(shù)組中的最小值：

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.數(shù)組的反轉(zhuǎn)：

/*
* 數(shù)組的反轉(zhuǎn)：
* 本來的樣子：[1,2,3,4]
* 反轉(zhuǎn)的樣子:[4,3,2,1]
* 不能使用新的數(shù)組
*
* 思路：
* 1.數(shù)組的反轉(zhuǎn)是兩個對稱位置的數(shù)據(jù)交換
* 2.需要兩個索引，min和max
* 3.需要一個臨時變量
* 4.條件判斷，當(dāng)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};
        //遍歷原來的數(shù)組
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
        //反轉(zhuǎn)
        for (int min=0,max = arr.length-1; min < max ; min++ , max-- ){
            int temp = arr[min];
            arr[min] = arr[max];
            arr[max] = temp;
        }
        //遍歷新的數(shù)組
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

數(shù)組也可以作為方法的參數(shù)：
當(dāng)調(diào)用方法的時候，向小括號傳參，事實上傳遞的是數(shù)組在堆內(nèi)存中的地址值。
數(shù)組也可以作為方法的返回值：
其實返回的也是數(shù)組在堆內(nè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;
    }
}

日本欧美一区-日本欧美一区二区三区片-日本强好片久久久久久AAA-日本-区一区二区三区A片-日本人伦一区二区三区-日本人妻A片成人免费看

電子開發(fā)網(wǎng)

JAVA語法程序匯總_Java基礎(chǔ)語法總結(jié)