Java基礎語法
Java基礎語法java
Java語法的組成
一、關鍵字
關鍵字的定義和特色
定義：被Java語言賦予了特殊含義的單詞
特色：關鍵字中全部字母都爲小寫
注意事項：
1) true、false、null 不是關鍵字！是字面量。
2) main 不是關鍵字！是一個特殊單詞，能夠被 JVM 識別，主函數是固定格式，做爲程序的入口程序員
二、標識符：給類、方法、變量起的名字。
定義合法標識符規則：
1) 必須以字母或下劃線或 $ 符號開始，其他字符能夠是字母、數字、$ 符號和下劃線。
2) 只能包含兩個特殊字符，即下劃線 _ 和美圓符號 $ 。不容許有任何其餘特殊字符。
3) 數字不能夠開頭。
4) 不可使用Java中的關鍵字。
5) Java中嚴格區分大小寫。
6) 標識符不能包含空格。
* 使用駝峯命名法，爲了提升閱讀性，見名知意。Java中的名稱規範：[參照：阿里巴巴Java開發手冊.pdf]
經常使用的命令規範：
1) 包名(package)：多單詞組成時全部字母都小寫。xxxyyyzzz
2) 類名接口名：多單詞組成時，全部單詞的首字母大寫。XxxYyyZzz
3) 變量名和函數名：多單詞組成時，第一個單詞首字母小寫，第二個單詞開始每一個單詞首字母大寫。xxxYyyZzz
4) 常量名：全部字母都大寫。多單詞時每一個單詞用下劃線鏈接。XXX_YYY_ZZZ
三、註釋：用於註解說明解釋程序的文字就是註釋。註釋的好處：提升了代碼的閱讀性。
Java中的註釋格式[三種]：
> 對於單行和多行註釋，被註釋的文字，不會被JVM（java虛擬機）解釋執行。[查看源文件的屬性大小做比較比較直觀的瞭解]
> 對於文檔註釋，是java特有的註釋，其中註釋內容能夠被JDK提供的工具 javadoc 所解析，生成一套以網頁文件形式體現的該程序的說明文檔。註釋是一個程序員必需要具備的良好編程習慣。將本身的思想經過註釋先整理出來，在用代碼去體現。由於代碼僅僅是思想的一種體現形式而已。
四、常量和變量
常量：在程序運行過程當中，其值不能夠改變的量。
4.1 Java中常量的分類
1) 整數常量：全部整數
2) 小數常量：全部小數
3) 布爾(boolean)型常量：較爲特有，只有兩個數值。true false。
4) 字符常量。將一個數字字母或者符號用單引號( ' ' )標識。
5) 字符串常量。將一個或者多個字符用雙引號(" ")標識。
6) null常量。只有一個數值就是:null.
4.2 對於整數：有四種表現形式。
二進制：0,1 ，滿2進1
八進制：0-7 ，滿8進1. 用0開頭表示。
十進制：0-9 ，滿10進1.
十六進制：0-9，A-F，滿16進1. 用0x開頭表示。(數字0，並非字母O)
變量(Variable)：內存中一塊存儲空間，可保存當前數據。在程序運行過程當中，其值是能夠改變的。
1) 必須聲明而且初始化之後使用（在同一個做用域中不能重複聲明變量）！
2) 變量必須有明確類型（Java 是強類型語言）。
3) 變量有做用域（變量在聲明的地方開始，到塊｛｝結束）。變量做用域越小越好。
4) 局部變量在使用前必定要初始化！成員變量在對象被建立後有默認值，可直接用。
5) 在方法中定義的局部變量是在該方法被加載時建立。
局部變量：在方法內部定義的變量，稱爲局部變量(代碼塊裏面變量).
局部變量的特色：局部變量必須先定義後使用；局部變量的內存在棧中分配。
爲何要定義變量：用來不斷的存放同一類型的常量，並能夠重複使用
使用變量注意：
一、變量的做用域（一對{ }之間有效）
二、定義變量的格式：數據類型 變量名 = 初始化值 => int x=3;
三、局部變量的命名規範：首字符小寫，若是是多個單詞構成，從第二個單詞開始每一個單詞的首字符大寫。
四、終態變量的命名規範：全部字符所有大寫，多個單詞構成，使用下劃線分隔。
注：格式是固定的，記住格式，以不變應萬變。輔助理解：變量就如同數學中的未知數。算法
* 變量內存分析圖
編程
注意事項：
1) 字面量、常量和變量的運算機制不一樣，字面量、常量由編譯器計算，變量由運算器處理，目的是爲了提升效率。
2) 無論是常量仍是變量，必須先定義，纔可以使用。即先在內存中開闢存儲空間，纔可以往裏面放入數據。
3) 無論是常量仍是變量，其存儲空間是有數據類型的差異的，即有些變量的存儲空間用於存儲整數，有些變量的存儲空間用於存儲小數。數組
五、Java的數據類型(基本數據類型、引用數據類型)
Java語言是強類型語言，對於每一種數據都定義了明確的具體數據類型，在內存中分配了不一樣大小的內存空間安全
Java引用數據類型：複合數據類型、複雜數據類型
3個引用數據類型：
類： class
接口：interface
數組：[]
數據的具體類型有2種指定的方式：顯式指定，隱式指定(一般是針對字面值。由編譯器默認指定)
數據類型的做用：
1) 決定了佔用內存空間的大小。
2) 底層的存儲的格式
3) 決定了最終顯式的形式。
字符類型
char 類型：能夠看成整數來對待。 無符號的短整型。沒有負數.取值範圍 [0-65535]
字符集：字符的集合。字符集合中的每個字符都對應着一個惟一的整數。
1) ASCII：單字節字符集。只用到了一個字節的後7位。128個字符。
2) ISO8859-1：西歐使用的字符集，單字節字符集。256個字符。兼容了ASCII。
3) GB2312：雙字節字符集。兼容了ASCII。主要收錄了中文簡體。
4) GBK：兼容了 gb2312.增長了繁體中文，還有各個少數民族的符號。
5) UTF-8：三字節的字符集。兼容了 ASCII。
6) Unicode：萬國碼。java 使用的字符集。jvm 使用的。保證全部的國家的符號都能識別。
example[經常使用的基本數據類型]
dom
1 package com.boom.test; 2 /** 3 * 整數默認：int 4 * 小數：double 雙精度 5 * @project_name testJava 6 * @class_name Test01 7 * @author Dilraba 8 */ 9 public class Test01 { 10 public static void main(String[] args) { 11 //數據類型 變量名 = 初始化值 12 byte b=3; 13 System.out.println("輸出byte類型=>b="+b); 14 short s=4000; 15 System.out.println("輸出short類型=>s="+s); 16 int i=12; 17 System.out.println("輸出int類型=>i="+i); 18 long l=12345678; 19 System.out.println("輸出long類型=>l="+l); 20 long l2=541646465464465564l;/*數值較大取值末尾+l*/ 21 System.out.println("輸出long類型=>l2="+l2); 22 // float f= 2.3;/*報錯：單精度*/ 23 float f2=2.3f;/*強制轉換f*/ 24 System.out.println("輸出float類型=>f2="+f2); 25 double d=2.5; 26 System.out.println("輸出double類型=>d="+d); 27 char ch='C'; 28 System.out.println("輸出char類型=>ch="+ch); 29 boolean b1=true; 30 b1=false; 31 System.out.println(b1); 32 } 33 }
轉義字符(7種經常使用的轉義字符)
\t： 水平製表符 對應着鍵盤上的Tab鍵。
做用： \t佔用的半角的個數爲[1-8]。從\t包括以前的輸出的內容。總共佔用的半角的位數必須是8的倍數。\t用來補齊8個半角位的倍數的。
\b：退格符： 對應着鍵盤上的 Backspace 鍵。
\r： 回車符： 讓光標回到當前行的行首，後續的輸出從行首輸出。
\n：換行符： 讓光標去下一行。
Enter 鍵對應兩個字符：\r\n 讓光標去到下一行的行首。jvm
\' ： 字符單引號。
\" ：字符雙引號。
\\ ：字符反斜槓ide
六、運算符
算術運算符
概念：
一、操做數：參與運算的數據 稱爲操做數。
二、表達式：運算符和操做數的總體 稱爲表達式。單獨的一個操做數也能夠看做一個最簡單的表達式。 int age = 1+1;
三、返回值：操做數 或者是 表達式 參與 運算的結果。
四、一元運算符：只須要一個操做數的運算符。也叫作 單目運算符。
五、二元運算符：須要兩個操做數的運算符。也叫作 雙目運算符。
六、三元運算符：須要三個操做數的運算符。也叫作 三目運算符。
注意：參與全部運算的數據，都是操做數 或者 表達式的 返回值 參與的。模塊化
e-image && code：
/ 和 % 的應用 [ 求隨機數的千位、百位、十位、個位 ]
1 package com.boom.test; 2 3 import java.util.Scanner; 4 5 /** 6 * @project_name testJava 7 * @class_name Test01 8 * @author Dilraba 9 */ 10 public class Test01 { 11 public static void main(String[] args) { 12 // 任意四位數 13 Scanner scanner = new Scanner(System.in); 14 System.out.print("請輸入任意四位數："); 15 int num = scanner.nextInt(); 16 int unit = num % 10;// 個位 17 int decade = num / 10 % 10; // 十位 18 int hundred = num / 100 % 10;// 百位 19 int Thousands = num / 1000 % 10;// 千位 20 System.out.println("千位：" + Thousands + "\n百位：" + hundred + "\n十位：" + decade + "\n個位：" + unit); 21 } 22 }
i++和++i的異同之處
共同點：
一、i++ 和 ++i 都是變量自增+1，都等價於i=i+1
二、若是i++，++i是一條單獨的語句，二者沒有任何區別。
三、i++和++i的使用僅僅針對變量。5++和++5會報錯，由於5不是變量。
不一樣點：
若是i++，++i 不是一條單獨的語句，他們就有很大的區別。
i++ ：先運算後 +1
++i ： 先+1 後運算
賦值運算符
符號： = 符合賦值運算符：[Java中：+=、-=、*=、/=、%=] => 類型自動提高
複合賦值運算符特色：
1，生成的字節碼文件要稍微小一點點(內存消耗小)。
2，隱含一個強制類型的轉換。強制轉換的類型爲 左邊變量的類型
* 左值 的類型 要和 右值表達式的返回值的類型 要兼容，否則會出現精度丟失。
示例：int a,b,c; a = b = c =3;
int a = 3; a += 5; => a+=5 <==> a=a+5
example
1 package com.boom.test; 2 3 import java.util.Scanner; 4 5 /** 6 * 賦值運算符 = += -= *= /= %= 7 * @project_name testJava 8 * @class_name Test01 9 * @author Dilraba 10 */ 11 public class Test01 { 12 public static void main(String[] args) { 13 int num = 3; 14 num += 2; // num = num +3 =5 15 System.out.println("num=" + num);// 5 16 17 short s = 5; 18 s += 2;// 自動類型提高 s=s+2 19 /* 20 * s=s+4;//丟失精度 *報錯 改爲下面代碼 強制轉換 s=(short)+(s+4); 21 */ 22 System.out.println("s=" + s); 23 } 24 }
比較運算符(關係運算符)
一、>、<、>=、<= ：只適用於 數值型包括 char 類型的數據。
二、== != 適用於 java支持的全部的數據類型。
example
邏輯運算符
邏輯運算符：參與邏輯運算的操做數必須是 boolean 類型的數據。邏輯表達式的 返回值 也是 boolean 類型。在Java中不能夠寫成3<x<6，應該寫成x>3 & x<6
短路與（ && ） 、條件與 （ & ）區別：
&&：若是表達式左邊爲真，表達式右邊參與運算；若是左邊爲假，那麼右邊不參與運算，直接返回整個邏輯表達式的結果爲false 。
& ：表達式左邊運算結果不管真假，右邊都進行運算。
* 短路與的效率每每高於邏輯與，一般使用短路與 &&
短路或（ || ） 、 條件或 （ | ）區別：
|： 不管左邊運算結果是什麼，右邊參與運算；
||：當左邊爲true時，右邊不參與運算；直接返回整個邏輯表達式的值 爲 true
異或( ^ )與或( | )的不一樣之處是：只有表達式左右都爲true時，結果爲false，當兩邊都爲false，結果也爲false
位運算符
按位與( & )：二元運算符。
規則：低位對齊，進行按位與。 對應的位 有0則0 全1則1.
1：能夠將某個整數的某些二進制位設置爲0。
2：能夠獲得某一個數的制定區間的二進制表示的數據。
按位或( | )：二元運算符。
規則：低位對齊，進行按位或。對應的位，有1則1，全0則0
若是兩個操做數 對應的位上沒有全1 的，那麼進行按位或和加的效果一致
按位異或( ^ )：二元運算符。
規則：對應的位上 相異爲1，相同爲0
特色：一個數前後和同一個數據異或兩次，結果是它自身
異或簡單加密應用
按位取反( ~ ) ：一元運算符。
規則：全部的二進制位0--->1 1--->0
System.out.println(~0);//-1
移位運算符
<< 左移 ：高位被移走，包括符號位。低位補0.
>> :帶符號右移 ：低位被移走，高位空出來的補符號位，正數補0 負數補1.
三元運算符( 條件運算符 )
Java 中惟一的三目運算符。 須要三個操做數。能夠是java 支持的任意的表達式。兩個表達式的返回值的類型 須要兼容。
格式：條件表達式 ? 表達式1 : 表達式2
1）條件表達式爲true，返回表達式1；
2）條件表達式爲false，返回表達式2；
示例：Example
兩值互換的幾種方法：
一、定義第三方變量進行互換
二、數值直接運算 缺：數值過大超過int取值範圍，出現強制轉換，數據發生變化
三、異或：一個數異或同一個數兩次，結果仍是這個數(閱讀性差)
運算符的優先級
1：乘除取餘 大於 加減。
2：一元運算符 大於 二元運算符 的優先級。
3：二元運算符的優先級高於三元運算符的優先級。
4：賦值運算符優先級最低。
5：配合小括號使用。
附加：random隨機數
一、Math.random();返回值是一個隨機的double 值
語句：Math.random() * (MAX-MIN) + MIN
取整：int value = (int)(Math.random() * (MAX-MIN) + MIN);
二、導入import java.util.Random產生隨機數
位移運算符：一條語句產生隨機數：int value = (random.nextInt()>>>1)%(MAX-MIN)+MIN;
練習：隨機數+三目運算符應用[ 求三個數的最大值 ]
1 // 得到隨機數 2 import java.util.Random; 3 public class RandomNumber{ 4 public static void main(String[] args){ 5 // 定義隨機數區間 6 final int MIN = 1,MAX = 100; 7 Random random = new Random(); 8 int num1 = (random.nextInt()>>>1)%(MAX-MIN)+MIN; 9 int num2 = (random.nextInt()>>>1)%(MAX-MIN)+MIN; 10 int num3 = (random.nextInt()>>>1)%(MAX-MIN)+MIN; 11 12 // int num1 = (int)(Math.random()*(MAX-MIN)+MIN); 13 // int num2 = (int)(Math.random()*(MAX-MIN)+MIN); 14 // int num3 = (int)(Math.random()*(MAX-MIN)+MIN); 15 16 17 int max = num1 > num2 ? num1:num2; 18 max = max > num3 ? max:num3; 19 System.out.print("num1 = "+num1+"\tnum2 = "+num2+"\tnum3 = "+num3+"\tmax=>"+max); 20 21 } 22 }
七、基本數據類型轉換
方式：自動類型轉換（也叫隱式類型轉換）， 強制類型轉換（也叫顯式類型轉換）
類型轉換：java 不支持 不一樣類型之間的運算。若是有不一樣類型之間的數據作運算的話，那麼首先第一步作同類型轉換。編譯器來完成這種轉換的。自動的完成的。
轉換的規則
1：全部的 byte、short、char 的值將被提高到int型。
2：若是一個操做數是long型，計算結果就是long型；
3：若是一個操做數是float型，計算結果就是float型；
4：若是一個操做數是double型，計算結果就是double型。System.out.println(6 % 123456L);// 2.0
上述的轉換都是 編譯器 來完成的。自動完成的。在編譯期完成類型的轉換，也就是將小類型的數據 看成大類型的數據來使用（若是須要）。
注意：1 和 2 自動轉換 是 絕對安全的。 三、4 有可能存在精度的損失。java 語法上這樣是容許的
自動類型提高
強制類型轉換。語法：(強制轉換爲的類型)(被轉換的數據);
example[ 類型自動提高 && 強制類型轉換 ]
1 /*類型提高&強制轉換*/ 2 class VarDemo2 3 { 4 public static void main(String[] args) 5 { 6 7 int x=2; 8 byte b=1; 9 x=x+b;//佔用較小的自動提高爲int型 10 System.out.println("x="+x);//x=3 11 12 byte b1=2; 13 b1=(byte)(b1+5);//強制類型轉換 14 System.out.println("b1="+b1); 15 //a=65+1=66 =>b 16 System.out.println("轉換後輸出字符:"+(char)('a'+1));//強制轉換爲char 輸出b 17 18 19 byte b2=3; 20 byte b3=7; 21 int s;/*強制轉換*/ 22 s=b2+b3;//s=10 23 System.out.println("s="+s); 24 25 //Integer.MIX_VALUE int類型最大最小值 26 int max=Integer.MAX_VALUE; 27 int min=Integer.MIN_VALUE; 28 System.out.println("int_MAX="+max+"\n"+"int_MIN="+min); 29 } 30 }
&& 獲得一個隨機字符[A-Z]or[a-z](大小寫也隨機)
1 // 獲得一個隨機字符[A-Z]or[a-z](大小寫也隨機) 2 import java.util.Random; 3 public class RandomCharTest{ 4 public static void main(String[] args){ 5 final int MAX = 'Z'+1; 6 final int MIN = 'A'; 7 // 獲得隨機大寫字符 8 char ranChar =(char)(Math.random()*(MAX - MIN)+MIN); 9 System.out.println("隨機大寫字符："+ranChar); 10 11 Random random = new Random(); 12 // 大小寫隨機 三目運算符進行判斷 13 boolean isUpperCase = random.nextBoolean(); 14 ranChar = isUpperCase ? ranChar : (char)(ranChar+32); 15 System.out.println("獲得隨機字符："+ranChar); 16 17 } 18 }
八、Java流程控制[ 順序、分支、循環]
if 單分支
條件：必須是一個 boolean 表達式。返回值爲 boolean 值的表達式。
if 代碼塊：一個使用 一對花括號{ } 封閉的代碼塊。代碼塊組成能夠是java 支持的任意行數的代碼。
執行過程：
1：首先計算條件 的返回值。若是是 返回值 爲 true。那麼執行 if 代碼塊中全部的內容。
2：若是條件的返回值 爲 false。那麼就跳過全部的 if 代碼塊中的內容。
&& IfTest小練習
1 //求兩個隨機數的最大值 範圍[0-20]. 2 //需求：產生一個隨機數，範圍[0-20]. 來表明一個年齡 age， 3 //使用if 語句，若是 age [0-3] 輸出 尚未上學 [4-6] 幼兒園小朋友 [7-12] 小學生 [13-15] 中學生 [16-18] 高中生 [19-22] 大學生。 4 import java.util.Random; 5 public class IfTest { 6 public static void main(String[] args) { 7 // 定義最大最小值 8 final int MAX = 21; 9 final int MIN = 0; 10 // 產生兩個隨機數 11 int num1 = (int)(Math.random()*(MAX - MIN)+MIN); 12 int num2 = (int)(Math.random()*(MAX - MIN)+MIN); 13 System.out.println("num1=" +num1 +"\nnum2=" +num2); 14 15 // 求兩個隨機數的最大值 16 // 最大值賦值給num1 17 int max = num1; 18 if(num1 < num2) { 19 max = num2; 20 } 21 System.out.println("max="+max); 22 23 System.out.println(); 24 25 //產生一個隨機的年齡 26 int age = (int)(Math.random()*(MAX-MIN)+MIN); 27 System.out.println("age="+age); 28 if(age >=0 && age <=3) { 29 System.out.println("尚未上學！"); 30 } 31 if(age >=4 && age <=6) { 32 System.out.println("幼兒園小朋友！"); 33 } 34 if(age >=13 && age <=15) { 35 System.out.println("初中生！"); 36 } 37 if(age >=7 && age <=12) { 38 System.out.println("小學生！"); 39 } 40 if(age >=16 && age <=18) { 41 System.out.println("高中生！"); 42 } 43 if(age >=19 && age <=22) { 44 System.out.println("大學生！！"); 45 } 46 47 } 48 }
if-else 雙分支
執行過程：
1：若是if 後的條件成立 true 那麼就執行 if 代碼塊中的內容。 不執行 else 中的內容。
2：若是if 後的條件不成立 false ，那麼不會執行 if 代碼塊中的內容， 執行 else 中的內容。
注意：
1：else 代碼塊不能單獨存在。
2：若是 if 代碼塊 或者是 else 代碼塊中的內容爲一條java 語句，那麼兩個大括號均可以省略。建議大括號添加。
3：if else 兩個代碼塊 執行且必需要執行某一個代碼塊中的內容。 條件互斥的。
當 if else運算後有具體的結果，可簡化三元運算符
&& if-else小練習
1 /** 2 需求：模擬一次打鬥 隨機產生一我的的生命值hp[50-100],而後打印。 3 而後才隨機產生一個傷害值[30-60],暴擊的機率爲30%，1.8倍傷害.而後將傷害值也打印 4 若是出現暴擊的話，要提示。 5 而後根據這次的傷害和生命值，最後輸出 人 是否被 over掉。 若是沒有over，輸出 最後的血量 hp。 6 */ 7 public class IfElse{ 8 public static void main(String[] args){ 9 // 定義最大最小值血量 10 final int MAX_HP = 101; 11 final int MIN_HP = 50; 12 13 // 定義最大最小值傷害 14 final int MIN_DAM = 30; 15 final int MAX_DAM = 61; 16 17 // 暴擊百分比機率 18 final double CRITICAL_PERCENT = 0.3; 19 // 產生1.8倍的傷害 20 final double CRITICAL_DAM = 1.8; 21 22 // 獲得隨機生命值 23 int hp = (int)(Math.random()*(MAX_HP - MIN_HP)+MIN_HP); 24 System.out.println("hp = "+hp); 25 26 // 隨機傷害值 27 int damage = (int)(Math.random()*(MAX_DAM - MIN_DAM)+MIN_DAM); 28 System.out.println("damage = "+damage); 29 30 // 計算是否產生了暴擊 31 // Math.random [0 - 1.0 ] 32 // 定義隨機數 33 double random = Math.random(); 34 System.out.println("random ="+random); 35 36 /** 定變量是否產生了暴擊,用產生的random去比較。 37 random<0.3 true[ 產生暴擊 ] 38 random>0.3 false[ 沒有被暴擊 ] 39 40 */ 41 // 定義變量來表示 是否產生了暴擊 42 boolean isCritical = random <CRITICAL_PERCENT; 43 /** 44 true ：產生暴擊 45 false：沒有產生暴擊 46 */ 47 System.out.println(isCritical); 48 if(isCritical){// 出現暴擊 49 damage *= CRITICAL_DAM; 50 System.out.println("本次攻擊爲【~~暴擊~~】。產生：["+damage+"] 點傷害"); 51 }else{// no 52 System.out.println("本次沒有被暴擊。產生：["+damage+"] 點傷害"); 53 } 54 55 hp -= damage; 56 if(hp <= 0){ 57 hp = 0; 58 System.out.println("Over……"); 59 }else{ 60 System.out.println("活着 剩餘血量爲："+hp); 61 } 62 } 63 }
if-else if-else 多分支
執行過程：
1：首先判斷 條件-1 成立 true 執行代碼塊-1.後面全部的代碼塊都將被跳過。
2：若是第一個條件不成了 false 。那麼跳過 代碼塊-1 繼續判斷 條件-2.若是成立，執行 代碼塊-2 跳事後面全部的，不成立，跳過代碼塊-2，繼續判斷下一個條件。
3：若是全部的條件都不成立。那麼執行 else 後的最後的代碼塊
注意：
1：else 的數量應該是小於等於 if 的個數的。 else 和 它前面的離它最近的if 配對。
2：if 後的若干個條件應該是條件互斥的。
3：這個多分支的選擇語句，執行且僅執行其中的一個代碼塊。
4：最後的else 能夠沒有。若是沒有最後else 以及代碼塊的話，那麼這麼多的分支有可能一個都不成立。
5：if else if else 能夠嵌套使用，不建議嵌套太深。通常不要超過三層。
&& if-else if-else
1 // 隨機獲得一個整數 [0-100] ，定義分數變量 score 用來存儲該隨機數。打印當前分數 2 // 而後，若是score在[90-100] 打印 成績爲A級。 在[80-89] 打印爲B級 [60-79] C 級 剩餘部分 爲 D級。 3 // 使用if else if else 實現。 4 public class IfElseIfElse{ 5 public static void main(String[] args){ 6 final int MIN = 0; 7 final int MAX = 101; 8 9 int score = (int)(Math.random()*(MAX-MIN)+MIN); 10 System.out.println("score = "+score); 11 12 if(score >= 90){ 13 System.out.println("A"); 14 }else if(score >= 80){ 15 System.out.println("B"); 16 }else if(score >= 60){ 17 System.out.println("C"); 18 }else{ 19 System.out.println("D"); 20 } 21 } 22 }
&& if-else if-else 和 多個if 的區別
switch 多分支選擇結構
switch語句特色：
1：switch語句條件變量取值類型類型（JDK1.5以前）：byte short int char enum(jdk1.5之後) String(jdk1.7之後)
2：case之間與default沒有順序。先執行第一個case，沒有匹配的case執行default。
3：結束switch語句的兩種狀況：遇到break，執行到switch語句結束。
4：若是匹配的case或者default沒有對應的break，那麼程序會繼續向下執行，運行能夠執行的語句，直到遇到break或者switch結尾結束。
if語句和switch區別：
if：
一、對具體的值進行判斷；
二、對區間判斷；
三、對運算結果是boolean類型的表達式進行判斷；
switch：
一、對具體值進行判斷；
二、值的個數一般固定的；
三、對於幾個固定值得判斷，使用switch語句，switch將具體的值加載內存，效率相對高；
&& SwitchDemo
1 public class SwitchDemo 2 { 3 public static void main(String[] args) 4 { 5 int x=3; 6 switch (x)//byte,short,int,char 7 { 8 case 4: 9 System.out.println("a"); 10 break; 11 case 3: 12 System.out.println("b"); 13 break; 14 default: 15 System.out.println("d"); 16 } 17 18 19 //switch char類型演示 20 int a=3,b=9; 21 char opr='+'; 22 switch (opr) 23 { 24 case '+': 25 System.out.println(a+b); 26 break; 27 case '-': 28 System.out.println(a-b); 29 break; 30 case '*': 31 System.out.println(+a*b); 32 break; 33 case '/': 34 System.out.println(a/b); 35 break; 36 default: 37 System.out.println("此功能爲開發！！！"); 38 } 39 } 40 }
&& SwitchTest
1 class SwitchTest 2 { 3 public static void main(String[] args) 4 { 5 //用戶輸入數據對應的星期 6 int week=1; 7 switch (week) 8 { 9 case 1: 10 System.out.println("星期一"); 11 break; 12 case 2: 13 System.out.println("星期二"); 14 break; 15 //以此類推 16 } 17 18 ////////////////////////////////// 19 20 int month=8; 21 switch (month) 22 { 23 case 3: 24 case 4: 25 case 5: 26 System.out.println(month+"月是春季"); 27 break; 28 case 6: 29 case 7: 30 case 8: 31 System.out.println(month+"月是夏季"); 32 break; 33 case 9: 34 case 10: 35 case 11: 36 System.out.println(month+"月是秋季"); 37 break; 38 case 12: 39 case 1: 40 case 2: 41 System.out.println(month+"月是冬季"); 42 break; 43 default: 44 System.out.println(month+"月無對應的季節！！！"); 45 } 46 } 47 }
九、java循環[while 、 do-while 、 for 、jdk1.5 for-each ] 循環三要素：A．循環變量初值 B．循環條件 C．循環變量增量
循環的構成：
1：循環控制部分
1）循環條件初始化
2）循環條件
3）迭代 改變循環條件的
2：循環體
解釋：
1：循環條件： 一個 boolean 表達式
2：循環體： java 的任何的代碼。
執行過程：
1：先判斷循環條件是否成立 true ，若是成立，那麼就執行循環體，而後繼續判斷循環條件，依此類推 。
2：直到 循環條件 變成 false，當即結束整個while 循環。
注意：
1：循環體 若是是一句 代碼，大括號能夠省略(不建議省略)。
2：不要在循環條件後 添加分號。
3： while 循環有可能一次循環體都不執行，若是 一開始 條件就是 false。
4：通常在循環體中 去改變循環條件，來達到結束循環的目的。
&& 兩種形式寫1-100 奇數之和
&& 奇數之和
&& whileTest
do while 循環
執行的過程：
1：先會執行一次循環體。
2：而後再判斷循環條件，條件成立，繼續執行循環體，反覆 判斷<-->執行，不成立就直接退出循環
while 和 do while 的區別
1）語法不一樣
2）do while 不管條件是否知足，循環體至少執行一次； while 有可能一次循環體都不能執行。
&& do while 小練習
綜合練習：小遊戲[ 石頭、剪子、布 ]
1 //和計算機 石頭 剪刀 布，1，石頭，2，剪刀，3，布。5局3勝。循環實現。 2 /** 3 常量：石頭，剪刀，布 最大勝利的次數。 4 變量：計算機隨機值，玩家選擇的，電腦勝利的場數，玩家勝利的場數，總局數。 5 */ 6 import java.util.Scanner; 7 public class GameTest{ 8 public static void main(String[] args){ 9 // 定義石頭剪子布的終態常量 10 final int STONE = 1; // 石頭 11 final int SCISSORS = 2; // 剪刀 12 final int CLOTH = 3; //布 13 14 // 定義最大勝利的次數 15 final int MAX_WIN_CONUT = 3; 16 17 // 定義電腦、玩家的隨機數字，初始化爲0 18 int computerNumber = 0; 19 int playerNumber = 0; 20 21 // 定義電腦、玩家的勝利次數 22 int computerWinCount = 0; 23 int playerWinCount = 0; 24 25 // 定義總得局數 26 int counter = 1; 27 28 // 產生隨機數，建立掃描器進行隨機數的產生 29 Scanner scanner = new Scanner(System.in); 30 31 /** while循環判斷 32 電腦勝利總次數、玩家勝利總次數小於最大總次數 33 */ 34 35 while(computerWinCount < MAX_WIN_CONUT && playerWinCount < MAX_WIN_CONUT){ 36 // 顯示每次開始的局數 37 System.out.println("******第[ "+counter+"]局開始了******"); 38 /** 39 保證玩家輸入一個正確的數字 40 玩家輸入的是否是一個數字 若是不是數字。用接收字符串的方式去接收。 41 若是是數字，是否在範圍內。 42 */ 43 while(true){ 44 // 玩家輸入選擇 45 System.out.println("請選擇：[ 1-->石頭 ][ 2-->剪刀 ][ 3-->布 ]"); 46 boolean isInputInt = scanner.hasNextInt(); 47 if(isInputInt){ 48 playerNumber = scanner.nextInt();// 輸入的是正數 49 if(playerNumber < STONE || playerNumber > CLOTH){//錯誤數據區間 50 System.out.println("輸入出錯。。。請從新輸入！"); 51 }else{ 52 //輸入了正確的內容，跳出循環繼續後續的內容 53 break; 54 } 55 }else{ 56 scanner.next(); 57 System.out.println("輸入了非法的內容~~~請從新輸入！"); 58 } 59 } 60 61 // 電腦隨機選擇 62 computerNumber = (int)(Math.random()*(CLOTH-STONE)+STONE); 63 // 打印選擇和隨機的結果[電腦 or 玩家] 64 65 // 打印電腦隨機的選擇[if else] 66 if(computerNumber == STONE){ 67 System.out.println("[電腦]選擇的是[石頭]"); 68 }else if(computerNumber == SCISSORS){ 69 System.out.println("[電腦]選擇的是[剪刀]"); 70 }else{ 71 System.out.println("[電腦]選擇的是[ 布]"); 72 } 73 74 // 打印玩家的選擇[switch] 經過scanner接收參數進行選擇 75 switch(playerNumber){ 76 case STONE: 77 System.out.println("[玩家]選擇的是[石頭]"); 78 break; 79 case SCISSORS: 80 System.out.println("[玩家]選擇的是[剪刀]"); 81 break; 82 case CLOTH: 83 System.out.println("[玩家]選擇的是[ 布]"); 84 break; 85 } 86 87 // 電腦和玩家進行比較，並輸出結果 88 switch(playerNumber){ 89 case STONE:// 玩家石頭 90 if(computerNumber == STONE){ 91 System.out.println("------ 平局 ------"); 92 }else if(computerNumber == SCISSORS){ 93 System.out.println("------ [玩家]勝利！------"); 94 playerWinCount++; 95 }else{ 96 System.out.println("------ [電腦]勝利！------"); 97 computerWinCount++; 98 } 99 break; 100 101 case SCISSORS:// 玩家剪刀 102 if(computerNumber == STONE){ 103 System.out.println("------ [電腦]勝利！------"); 104 computerWinCount++; 105 }else if(computerNumber == SCISSORS){ 106 System.out.println("------ 平局 ------"); 107 }else{ 108 System.out.println("------ [玩家]勝利！------"); 109 playerWinCount++; 110 } 111 break; 112 113 case CLOTH:// 玩家布 114 if(computerNumber == STONE){ 115 System.out.println("------ [玩家]勝利！------"); 116 playerWinCount++; 117 }else if(computerNumber == SCISSORS){ 118 System.out.println("------ [電腦]勝利！------"); 119 computerWinCount++; 120 }else{ 121 System.out.println("------ 平局 ------"); 122 } 123 break; 124 } 125 // 打印當前總比分 126 System.out.println("[電腦]vs[玩家] "+computerWinCount + " vs " + playerWinCount); 127 System.out.println("------ 第["+ counter++ +"]局結束了------ \n"); 128 129 } 130 // 總得結果 131 if(computerWinCount == MAX_WIN_CONUT){ 132 System.out.println("\n 最後[電腦勝利]了！總比分[電腦]vs[玩家] "+computerWinCount + " vs " + playerWinCount); 133 }else{ 134 System.out.println("\n 最後[玩家勝利]了！總比分[玩家]vs[電腦] "+playerWinCount + " vs " + computerWinCount); 135 } 136 137 } 138 }
for 循環
執行過程：
1：循環條件初始化部分，最早執行，並且僅執行一次。
2：接下來進行循環條件的判斷部分。成立 true，執行循環體。循環體執行完畢以後，執行 迭代部分。而後再進行循環條件的判斷。
3：循環條件一旦不成立，false，循環立馬結束。
注意：
1：只有在for 循環中 通常使用單字符的 局部變量， int i; i的做用域只在for 循環內。
2：for 循環 小括號中的三部分，均可以沒有。可是，兩個分號必需要有。
3：while與for能夠互換，區別在於for爲了循環而定義的變量在for循環結束就是在內存中釋放。而while循環使用的變量在循環結束後還能夠繼續使用。
4：最簡單無限循環格式：while(true) , for(;;),無限循環存在的緣由是並不知道循環多少次，而是根據某些條件，來控制循環。
&& 水仙花數：在100-999之間：每一位的三次冪之和等於其自己
1 /** 2 水仙花數：在100-999之間：每一位的三次冪之和等於其自己 3 */ 4 public class Demo { 5 public static void main(String[] args) { 6 for(int i = 100; i<= 999; i++) { 7 int hundred = i/100%10; 8 int decade = i/10%10; 9 int util = i%10; 10 int num = (hundred*hundred*hundred)+(decade*decade*decade)+(util*util*util); 11 if(num == i ) { 12 System.out.println(num); 13 } 14 } 15 } 16 }
流程跳轉語句[ break continue ]
break語句：應用範圍：選擇結構和循環結構。
當break語句單獨存在時，下面不要定義其餘語句，由於執行不到。
標號的出現，可讓這兩個語句做用於指定的範圍
continue語句：應用於循環結構，結束本次循環繼續下次循環。
當continue語句單獨存在時，下面不要定義其餘語句，由於執行不到
for 循環的嵌套
&& 百錢買雞小案例
1 // 雞翁一值錢五，雞母一值錢三，雞雛三值錢一。百錢買百雞，問雞翁、雞母、雞雛各幾何？ 2 public class DoubleLoopTest{ 3 4 public static void main(String[] args){ 5 6 for(int i=0;i<=20;i++){//公雞的數量 7 for(int j=0;j<=33;j++){//母雞的數量 8 for(int k=0;k<=300;k+=3){//小雞的數量 9 if(i+j+k == 100 && i*5 + j*3 +k/3 == 100){ 10 System.out.println("公雞:"+i+"\t母雞:"+j+"\t小雞:"+k); 11 } 12 } 13 } 14 } 15 System.out.println(""); 16 //效率相對較高的 17 for(int i=0;i<=20;i++){//公雞的數量 18 for(int j=0;j<=33;j++){//母雞的數量 19 int k = 100 -i -j;//小雞的數量 20 if(i*5 + j*3 +k/3 == 100 && k % 3 == 0){ 21 System.out.println("公雞:"+i+"\t母雞:"+j+"\t小雞:"+k); 22 } 23 } 24 } 25 26 27 } 28 }
Example
不一樣形狀的輸出 雙重For循環
正三角
倒三角
數字正倒着
乘法表test
三層For循環
十、方法method（函數 function = 功能） y=f(x)
1）方法的主要三要素：方法名、參數列表、返回值。
2）什麼是方法：一個算法邏輯功能的封裝，是通常完成一個業務功能，如：登陸系統，建立聯繫人，簡單說：方法是動做，是動詞。
3）方法名：通常按照方法實現的功能定名，通常使用動詞定義，通常使用小寫字母開頭，第二個單詞開始，單詞首字母大寫。如：createContact()
4）參數列表：是方法的前提條件，是方法執行依據，是數據。如：login(String id, String pwd) ，參數的傳遞看定義的類型及順序，不看參數名。
5）方法返回值：功能執行的結果，方法必須定義返回值，而且方法中必須使用 return 語句返回數據；若是無返回值則定義爲 void，此時 return 語句可寫可不寫； 返回結果只能有一個，若返回多個結果，要用數組返回（返回多個值）。
注意事項：
遞歸調用：方法中調用了方法自己，用遞歸解決問題比較簡練，只需考慮一層邏輯便可！可是須要有經驗。必定要有結束條件！如：f(1)=1; 遞歸層次不能太深。總之：慎用遞歸！
方法給咱們帶來的好處：
1：減小了代碼的冗餘性。將功能代碼進行封裝，提升了代碼的複用。
2：功能模塊化了。更利於代碼後期的修改維護。
a：方法的修飾符 static public 可讓方法具備一些特殊的屬性
b：方法的返回類型：能夠是java 支持的任意類型（8+3）+ void
c：方法的返回值的類型：
1.若是方法的返回類型不是void：表明該方法的功能執行完畢以後，必須有一個結果返回。方法的返回類型處寫咱們須要獲得的結果的類型
2.若是一個方法的功能只是執行了某些代碼，而不須要獲得一個執行的結果的值，那麼在方法的返回類型處 添加 void 便可
d：方法名：一種標識符。必定要見名知意思。 經過方法的名字來反映 方法實現的功能
e：參數列表(又稱形參列表)：
f：方法體：一堆花括號
return：使用的範圍：只能在方法體中使用
用法：
1：方法的返回類型不是 void 的。必須保證使用return 關鍵字返回一個與方法返回類型兼容的值
2：方法類型是 void 。直接使用 return ; 來結束方法
方法中只能調用方法，不能夠在方法內部定義方法
變量值互換內存解析圖
局部變量的回收：
方法內定義的都是局部變量，局部變量在棧中分配空間。方法一旦返回，結束，那麼在棧中對方法中的局部變量分配的內存所有回收
方法重載： overload
在一個類的內部，方法的名字相同，參數列表不一樣的方法。就稱爲方法的重載，與方法的返回類型無關
1 // 方法的重載 2 public class Temp { 3 public static void main(String[] args) { 4 5 int value1 = add(12,23); 6 double value2 = add(1.5,2.3); 7 int value3 = add(12,23,12); 8 System.out.println("value1 = " + value1); 9 System.out.println("value2 = " + value2); 10 System.out.println("value3 = " + value3); 11 } 12 // 兩個數int型相加 13 public static int add(int num1,int num2){ 14 return num1+num2; 15 } 16 // 兩個double類相加 17 public static double add(double num1,double num2){ 18 return num1+num2; 19 } 20 // 三個int型相加 21 public static int add(int num1,int num2,int num3){ 22 // 相同類型重載num1+num2功能 23 return add(num1,num2)+num3; 24 25 } 26 27 }
- 1. Java基礎——基礎語法
- 2. Java 基礎語法
- 3. java基礎語法
- 4. java 基礎語法
- 5. Java基礎語法
- 6. java語法基礎
- 7. Java語法基礎
- 8. JAVA基礎語法
- 9. Java——基礎語法
- 10. java--基礎語法
- 更多相關文章...
- • Kotlin 基礎語法 - Kotlin 教程
- • Scala 基礎語法 - Scala教程
- • Kotlin學習（一）基本語法
- • ☆基於Java Instrument的Agent實現
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. No provider available from registry 127.0.0.1:2181 for service com.ddbuy.ser 解決方法
- 2. Qt5.7以上調用虛擬鍵盤(支持中文)，以及源碼修改(可拖動，水平縮放)
- 3. 軟件測試面試- 購物車功能測試用例設計
- 4. ElasticSearch（概念篇）：你知道的, 爲了搜索…
- 5. redux理解
- 6. gitee創建第一個項目
- 7. 支持向量機之硬間隔（一步步推導，通俗易懂）
- 8. Mysql 異步複製延遲的原因及解決方案
- 9. 如何在運行SEPM配置嚮導時將不可認的複雜數據庫密碼改爲簡單密碼
- 10. windows系統下tftp服務器使用
- 1. Java基礎——基礎語法
- 2. Java 基礎語法
- 3. java基礎語法
- 4. java 基礎語法
- 5. Java基礎語法
- 6. java語法基礎
- 7. Java語法基礎
- 8. JAVA基礎語法
- 9. Java——基礎語法
- 10. java--基礎語法