新年快樂（新的一年也不要忘記學習呀～）
技術標籤：筆記
今日學習：
Java註釋
一般要求編寫程式必須有合理的註釋說明，註釋一般建議控制在20%-30%程式碼量上。但是具體實踐中一 般不會寫這麼多的註釋，但是不寫註釋是不合理的
// 單行 //多行 / /文件
IDE工具的安裝
如果使用文字編輯工具編寫程式碼，問題在於沒有任何提示，編碼效率低;而且不停的需要進行切換【編 輯發現問題–修改原始碼】。所以需要使用IDE工具(整合開發環境)，在工具中可以直接編寫程式碼，編 譯源程式並執行
Eclipse 是一個開放原始碼的、基於Java的可擴充套件開發平臺。該軟體是IBM使用java開發出來的並開源 的。就其本身而言，它只是一個框架和一組服務，用於通過外掛元件構建開發環境。幸運的是，Eclipse 附帶了一個標準的外掛集，包括Java開發工具(Java Development Kit，JDK)。官方下載網站 eclipse.org
Alt+/ 內容提示
Ctrl+Shift+F 格式化
Ctrl+shift+O 導包語句，該快捷鍵一次性可以匯入多個包 Ctrl+1 快速修復錯誤，但是該快捷鍵只能修復小錯誤
語法基礎
Java語言的源程式程式碼由一個或多個編譯單元組成，每個編譯單元可包含三個要素: 1、一個包宣告(可選)。 package com.yan; 名稱空間
2、任意數量引入語句。 import java.util.;
3、類的宣告和介面宣告 public class A{}
一個檔案中可以定義多個class，但是最多隻能由一個public class，因為檔名稱必須和public class類 名稱一致(大小寫在內);當然在一個檔案中的class名稱不能重複【實際上在一個包中的類名稱不能重 復】，如果檔案中沒有public class，則檔名稱沒有約束
或美元符號。
識別符號是區分大小寫，沒有長度限制，可以為識別符號取任意長度的名字
編碼規範
類名首字母大寫，大寫字母分詞 建議名詞 方法名稱首字母小寫，大寫字母分詞 變數名稱首字母小寫，大寫字母分詞 包名稱全小寫，使用域名反轉的方式定義
變數
變數是Java程式中的基本儲存單元，它的定義包括變數名、變數型別和作用域幾個部分
Java屬於強型別程式語言，變數型別一旦宣告，則不能進行修改 資料型別可以決定變數所需要的儲存空間大小和對應的處理邏輯 作用域是指變數生效的範圍，從定義的位置開始，到所在的{}結束為止
referance type)
4類 整數: byte 1B short 2B int 4B long 8B 預設為int 特殊字尾L/l 浮點數: float 4B double 8B 預設double 特殊字尾 f/F D/d
字元: 單引號 2B unicode[java預設0-65535]
布林: true、false
引用型別: 複雜型別
class/interface 陣列 null
注意:null屬於引用型別，所以int k=null;語法錯誤
複合資料型別
複合資料型別包括:class類、interface介面、陣列。
null 索引在執行時並沒有對應的型別，但它可以被轉換為任何型別(不能是簡單型別)。 索引型別的預設值就是null
包裝類
所謂包裝類，就是可以直接將簡單型別的變量表示為一個類，在執行變數型別的相互轉換時會大量使用 這些包裝類。 Java共有8個包裝類，分別是Boolean、Character、Byte、Short、Integer、Long、Float 和 Double，從字面上就可以看出它們分別對應於 boolean、char、byte、short、int、long、float和 double。
型別包裝類的作用
各種建構函式，如從字串來構造整數 一個對應型別的資料範圍:最大值、最小值 完成不同資料型別間轉換的方法 需要物件的地方:如Vector, HashTable,Session等
Java提供基本型別是為了提高效率，而提供包裝類是為了將基本來行看作物件，每個包裝類物件封裝了 一個基本值。
抽象類java.lang.Number
java.lang.Number是所有表示數字類的父類，可以根據數字型別的不同對抽象該類進行擴充套件，它實現了 序列化介面。主要定義了方法byteValue():byte、 shortValue():short、 intValue():int、 longValue():long、 floatValue():float和 doubleValue():double。
具體類java.lang.Boolean 1、建構函式有Boolean(boolean)和Boolean(String)。當字串是”true”的時候則建立boolean值為true的
物件，否則建立boolean值為false的物件
1 Doubledd=newDouble(1.23);//通過new運算子建立物件dd 2 System.out.println(dd.intValue());
ublic class Test01 {
public static void main(String[] args) {
//
} }
Boolean b1 = true;// false 自動裝箱操作
boolean b2 = b1;// 自動拆箱操作 //使用構造器建立Boolean型別物件
Boolean b3=new Boolean(false);
Boolean b4=new Boolean(“true”);//""是字串型別
Boolean b5=new Boolean(123); 語法錯誤，只能是boolean型別 /*
- 引數為String字串型別的實現原理為:
- ((s != null) && s.equalsIgnoreCase(“true”)) */
Boolean b6=new Boolean(“abcd”);
System.out.println(b6);
3.booleanValue():boolean 4.Boolean.valueOf(boolean) / (String):Boolean
針對字串和boolean型別的轉換一般不使用這麼繁瑣的方法
1 2 3
//將字串型別的資料轉換為boolean型別
Boolean b1=Boolean.valueOf(“true”);
boolean b2=Boolean.valueOf(“false”); //自動拆箱
1 2
3
String str=“false”;
Boolean bb=“true”.equals(str); //使用字串比較的方法equals，這個方法可以進行字元 串內容的比較，如果內容相等返回為true，否則false
System.out.println(bb);
具體類java.lang.Character 1.取值範圍為Character.MIN_VALUE(0)到Character.MAX_VALUE(65535) 2、Character.isUpperCase(char)判斷字元是否為大寫 / isLowerCase(char)是否為小寫:boolean Character.toUpperCase(char)將字元轉換為大寫 / toLowerCase(char)將字元轉換為小寫:char
1 2 3
4 5
6 7
Character c1=‘a’; //如果中文則返回都是false
System.out.println(Character.isUpperCase(c1)+"—
“+Character.isLowerCase(c1));
char c2=Character.toUpperCase(c1);//小寫轉大寫,實際上返回值為char型別，但是可以直 接賦值給Character型別，因為自動裝箱操作
Character c3=Character.toLowerCase(c1);//轉換為小寫 System.out.println(c2+”==="+c3);
Character.isDigit(char) / isLetter(char) / isLetterOrDigit(‘5’):boolean
具體開發中進行字母、數字之類的判定一般使用正則式進行，比上面的方法簡單直接，一般不使用 Character中提供的方法
具體類java.lang.Integer(Byte、Short、Long) 1.取值範圍為Integer.MIN_VALUE到Integer.MAX_VALUE。
2、Integer.toString(int資料，int進位制):String將資料轉換為int進位制的字串。Integer.toHexString(int) 是16進位制;Integer.toOctalString(int)是8進位制;Integer.toBinaryString(int)是2進位制的。 3、 Integer.parseInt(String，int進位制):int將字串按照int進位制轉換為10進位制的整數Integer.parseInt(“- FF”,16)=-255 4、Integer.valueOf((String，int進位制):Integer將字串按照int進位制轉換為10進位制的整數對 象。Integer.parseInt(“-FF”,16)=new Integer(-255)
1 2 3 4 5 6
//判斷是否為數字 System.out.println(Character.isDigit(c1));//‘0’<=c1 && c1<=‘9’ //判斷是否為Unicode字母 System.out.println(Character.isLetter(c1));
//判斷數字或者字母 System.out.println(Character.isLetterOrDigit(c1));
1 2 3 4 5
String str = “123”;
Pattern p = Pattern.compile("\d{3}");
Matcher m = p.matcher(str);
boolean bb=m.matches();
System.out.println(bb);
valueOf和parseInt的區別
public static Integer valueOf(String s) throws NumberFormatException 返回值得型別為包裝
類，底層實現其實就是parseInt
public static int parseInt(String s) throws NumberFormatException 返回值型別為原生型別 具體類java.lang.Double(Float)
1.取值範圍為Double.MIN_VALUE到Double.MAX_VALUE。另外有public static final常數 POSITIVE_INFINITY正無窮大(1/0)、NEGATIVE_INFINITY負無窮大(-1/0)和NaN不是數(0/0，其中 NaN!=NaN)
3.Double.valueOf(String):Double和Double.parseDouble(String):double
1 public static Integer valueOf(String s) throws NumberFormatException {
2 3}
return Integer.valueOf(parseInt(s, 10));
1 2 3 4 5 6 7
int kk=0; System.out.println(10/kk);//會出現一個異常java.lang.ArithmeticException //這是一個bug，應該程式設計嚴謹以處理這種問題
if(kk==0)
System.out.println(“不允許除數為0”); else
System.out.println(10/kk);
數值與字串的轉換
數值轉換為字串有3種方法: String s=String.valueOf(i)=Integer.toString(i)=””+i;
字串與數值的轉換
字串轉為數值型有2種方法: int i=Integer.valueOf(s).intValue(); int i=Integer.parseInt(s) / (s,int進位制)
int和Integer的區別[面試題,3star] int是常說的整形數字，是Java的8個原始資料型別Primitive Types(boolean、byte 、short、char、
int、float、double、long)之一。Java語言雖然號稱一切都是物件，但原始資料型別是例外。
Integer是int對應的包裝類，它有一個int型別的欄位儲存資料，並且提供了基本操作，比如數學運算、 int和字串之間轉換等。在Java 5中，引入了自動裝箱和自動拆箱功能boxing/unboxing，Java可以根 據上下文自動進行轉換，極大地簡化了相關程式設計。
1 2 3
4 5 6 7 8 9
//需要掌握的是10進位制數的字串和數值之間的轉換方法
String s1=“123”;
int kk=Integer.valueOf(s1); //如果s1中的資料不是數值則會出現異常報錯,中斷程式的運 行
int k2=Integer.parseInt(s1);
System.out.println(kk+"—"+k2);
int k3=123;
String s2=""+k3;
System.out.println(s2);
基於大部分資料操作都是集中在有限的、較小的數值範圍，在JDK1.5中新增了靜態工廠方法valueOf， 其背後實現是將int值為-128到127之間的Integer物件進行快取，在呼叫時候直接從快取中獲取，進而提 升構建物件的效能，也就是說使用該方法後，如果兩個物件的int值相同且落在快取值範圍內，那麼這個 兩個物件就是同一個物件;當值較小且頻繁使用時，推薦優先使用整型池方法(時間與空間效能俱 佳)。
如果有執行緒安全的計算需要，建議考慮使用型別AtomicInteger、AtomicLong 這樣的執行緒安全類。部分 比較寬的基本資料型別，比如 float、double，甚至不能保證更新操作的原子性，可能出現程式讀取到 只更新了一半資料位的數值。
常量
常量就是指在程式執行期間其值不能發生變化的資料，常量是固定的。如整型常量123，實型常量 1.23，字元常量’A’，布林常量true等
Java中的常量用final來實現，例如final double PI=3.14;注意宣告常量的時候可以不賦值，而在構造器結 構中賦初值，但是若在宣告時同時進行了賦值，則不可以在初始化結構中賦值了。
表示式
表示式就是運算子、運算元以及方法呼叫的序列，用來說明某個計算過程並返回計算結果
按照運算子功能來分，基本的運算子分包括算術運算子、關係運算符、位運算子、條件運算子等
算術運算子 +、-、、/、%、++、-- 關係運算符 >、<、>=、<=、==、!=
邏輯運算子 &&、 ||、 !。注意:邏輯計算支援短路操作
位運算子 &、|、^、~、<< 、 >>、>>>。注意:為運算子不支援短路操作 [考點] 賦值運算子 =，+=，-=，=，/= 三目條件運算子(?:)規則是完全一致的，使用的形式是: x ? y:z;
算術運算子
+、-、*、/、%、++、-- 整除:參與運算的雙方都是整數 10/3=3而不是3.33333
10./3=3.333…這裡由於10.是浮點數，則3會自動轉換為大型別並參與計算，所以最終是 10.0/3.0的計算 結果
final boolean out=true;
// out=false;語法報錯的原因是out是常量，一旦賦值則不允許在執行期間進行修改 if(out)
System.out.println(“我的第一次輸出”); System.out.println(“其它的輸出”); if(out)
System.out.println(“我的第二次輸出”);
計算次序為先乘除後加減，如果優先順序一致，則自動從左向右進行計算 10+2*5=20 %求餘(取模) 10%3=1實際就是10除以3求餘數
1 2 3 4 5 6 7 8
//假設總行數為10行，每頁3行，如何計算需要多少頁進行顯示
int rowsNum = 12;// 總行數
int rowsPerPage = 3;// 每頁行數
int pageNum = rowsNum / rowsPerPage;// 總頁碼數 System.out.println(pageNum);// 由於整除的問題，所以計算結果為3，這樣就會有資料丟失 if(rowsNum%rowsPerPage!=0)
pageNum=pageNum+1; System.out.println(“最終結果為:”+pageNum);
注意:求餘計算可以用於浮點數。浮點數沒有整除的概念，只能針對計算結果進行強制型別轉換(窄化操 作)
++和–是單目運算子 i++等價於i=i+1 i–等價於i=i-1
i++是先取值後計算，++i是先計算後取值
1 doubledd=-12.3;//求餘計算中符號不參與計算，所以計算結果為-2.4 2 System.out.println(dd%3.3);//執行結果為2.4000000000000012
1 2 3
double k = 100;
k–;// k=k-1;
System.out.println(k);
1 2 3 4 5 6 7
int k = 100;
System.out.println(k++);//100 先獲取k的當前值，然後再進行加1計算 System.out.println(k);//101
int k = 100;
System.out.println(++k);//101 先加1然後再取值 System.out.println(k);//101
1 2 3 4 5
int k = 100;
int i = 50;
int res = k+++i; //實際是按照k++ +i進行計算 System.out.println(res); //150 System.out.println(k + “—” + i); //101 50
1 2 3 4 5 6 7
int kk=3;
int res=(kk/2); //沒有語法錯誤，因為除數和被除數都是整數，所以計算結果為整數 System.out.println(res); //如果需要計算小數部分，則除數或者被除數之一必須為非整數
3./2=1.5
double res=(1.*kk/2); //因為1.是double型別的浮點數，所以計算結果一定是浮點數
一般會配合短路操作進行考核
比較運算子
、<、>=、<=、、!= 用於判斷兩個資料之間的大小關係，計算結果為boolean,如果成立返回為 true，否則為false
1 2 3 4 5 6 7
boolean bb = 1 > 2;
System.out.println(bb);
System.out.println(1 <= 2); //=是賦值計算 是等值判定 int kk; System.out.println(kk=3); System.out.println(kk3);
和=的區別
k=100;這是賦值運算子，意思是將=右邊的計算結果儲存在=左邊的變數中 k100這是比較計算，意思是判斷k是否值為100;如果是則返回true，否則false !=意思是判斷是否不等於，表示如果相等時返回false，否則返回true 由於浮點數無法精確存放，所以判斷k1.0這個寫法是錯誤的
正確寫法: a-b的絕對值小於1e-6
Java提供了一個工具類Math
Math中包含一些常見的數學計算的實現，例如三角函式、反三角函式等， abs()的方法實現求絕對值
Math.abs(d1-1)<1e-6 判斷浮點型別的變數d1的值是否為1
1 2 3 4 5 6 7 8 9
10
double d1 = 0.999999999;
double d2 = 1;
//一般不建議這種寫法，因為浮點數無法精確存放 System.out.println(d1==d2);
double res=Math.abs(d2-d1); //Math數學庫中提供的abs方法用於獲取絕對值 System.out.println(res);
if(res<1e-6)
System.out.println(“d1和d2相等”); else
System.out.println(“d1和d2不相等”);
floor(double):double 從小到大逼近引數最大整數 ceil(double):double從大到小逼近引數最小整數 round(double):double 四捨五入，計算時和符號無關 pow(double a, double b):double 計算a的b次方
1 2 3 4 5
int k = 100;
int i = 50;
int res = k+ ++i;//是按照k+(++i)進行計算 System.out.println(res); //151 System.out.println(k + “—” + i); //100 51
sqrt(double a):double 針對a進行開根號計算 邏輯運算子
&&與、 ||或、 !非 表達多個條件之間的關係。例如年齡大於等於18並且年齡小於65
計算規則:
&& 同真則真，其餘為假 || 同假則假，其餘為真 ! 非真則假，非假則真
注意:邏輯計算支援短路操作
1 age>=18&&age<65
1 2 3
age>1 || age<10 //邏輯錯誤，因為任意值都滿足條件 age>1 && age<10 //正確
1 2 3 4 5
int a = 2;
int b = 3;
boolean bb = a > 1 && b++ < 4;
System.out.println(bb);//true
System.out.println(a + “:” + b); //2:4
1 2 3 4 5 6
int a = -2;
int b = 3;
//因為++a>1值為false,所以b++<4並沒有執行，這就是短路操作 boolean bb = ++a > 1 && b++ < 4; System.out.println(bb);//false System.out.println(a + “:” + b);//-1:3
&&:與運算，含義是兩個條件必須同時成立，可以翻譯為並且 年齡大於等於18並且年齡小於65: age>=18 && age<65 ||:或運算，含義是兩個條件中成立一個即可，可以翻譯為或者 年齡小於18歲或者年齡不小於65 : age<18 || age>=65 演算法規則:同假則假，否則為真 !:非運算，含義是不是，用於對某個條件進行否定 年齡不小於18
寫法1:age >=18
寫法2: !(age<18) 演算法規則:非真則假，非假則真
短路運算
例如A && B:如果條件A為false,則不會執行B，因為根據運算規則結果一定是false，和B的值沒有關係 A||B:如果條件A為true，則不會執行B，因為格局運算規則結果一定是true，和B的值沒有關係 考核中主要配置++/–進行測試
位運算子
&按位與、|按位或、^按位異或、~按位取反、<<左移位 、 >>右移位，空位置補符號位上的值、>>>無 符號右移位，空位置補0
注意:為運算子不支援短路操作 [考點]
7&3=3 7|3=7 7^3=4 ~3=-4
賦值運算子
=，+=，-=，*=，/=
int k=100; 含義是將100賦值儲存在k對應的儲存單元中 k=k+3可以簡寫為k+=3
-= */ /=類似
考點【難度係數3】
1 2 3 4 5 6
int a = -2;
int b = 3;
//因為++a>1值為false,所以b++<4並沒有執行，這就是短路操作 boolean bb = ++a > 1 & b++ < 4; System.out.println(bb);//false System.out.println(a + “:” + b);//-1:4
1 2 3 4 5
int a=1;
int b=2;
short c1=1+2; //語法不報錯，因為編譯器可以判定結果不越界 short c2=(short)a+(short)b; //計算結果為int，所以這樣會報錯 short c3=(short)(a+b);//語法正確
1 2
3
short k=3;
k=k+3; //出現了一個語法錯誤，因為k+3這裡的3系統識別為int型別，所以計算時所有資料自動轉 換為int型別，必然計算結果也是int型別，將int型別的資料賦值給short型別變數----錯誤 System.out.println(k);
1 shortk=3;
2 k+=3; //沒有語法錯誤，因為+=這種符號中包含了自動型別轉換
三目條件運算子
規則是完全一致的，使用的形式是: x ? y:z; 計算規則
x是一個條件表示式 如果x計算結果為true，則返回y表示式的結算結果 否則返回z表示式的計算結果
考試題:
其他運算子
物件運算子instanceof用來判斷一個物件是否是某一個類或者其子類的例項。如果物件是該類或者其子 類的例項，返回ture;否則返回false
點.運算子用於訪問物件例項或者類的類成員函式
new運算子 用於建立一個新的物件或者新的陣列
運算子的優先順序
運算子這裡不用記憶，當不確定時，注意有個神器就是()小括號，可以使用它強制表達自己的編寫意圖
1 2 3
int k=-10;
int b=k>6?5:3;
System.out.println(b);
1 2 3 4 5
int a=5;
int b=3;
int res=++a>b–?a+++3:b—4;
System.out.println(res);//9
System.out.println(a+":"+b);//7:2
1 2 3
Object k1 = 123;
System.out.println(k1 instanceof Integer); //true
System.out.println(k1 instanceof Double); //false
1 2 3
System.out.println(Integer.MAX_VALUE);
int k1=12,k2=23;
System.out.println(Integer.max(k1, k2));
1 Datenow=newDate();
2 System.out.println(now);
結構化程式設計
結構化程式設計Structured programming是1960年代開始發展起來的一種程式設計典範。它採用子程式、 程式碼區塊、for迴圈以及while迴圈等結構來取代傳統的goto。希望藉此來改善計算機程式的明晰性、 品質以及開發時間，並且避免寫出麵條式程式碼。
已經證明，任何複雜的問題都可以三種基本演算法結構來描述:順序、選擇、迴圈。因此用計算機語句描
述的程式也包含三種基本結構
設計方法:使用流程圖表示演算法
流程圖是流經一個系統的資訊流、觀點流或部件流的圖形代表。在企業中，流程圖主要用來說明某一過 程。這種過程既可以是生產線上的工藝流程，也可以是完成一項任務必需的管理過程。常見的繪製工具 有Visio、PowerDesigner等
圓角矩形表示“開始”與“結束”; 矩形表示行動方案、普通工作環節用; 菱形表示問題判斷或判定(稽核/審批/評審)環節; 用平行四邊形表示輸入輸出; 箭頭代表工作流方向。
結構化程式設計原則
自頂向下、逐步求精、模組化
結構化程式設計還有一個重要的規定，那就是隻能使用順序結構、選擇結構、迴圈結構這三種基本結構
(或由它們派生出來的結構)來定義程式的流程
條件分支語句
Java語言提供了兩種判斷語句:if語句和switch語句。這兩種語句用於實現判斷，當符合某些條件時執行 某段程式碼，否則將不執行
語法規則1:
要求使用者輸入學生性別，如果輸入true則顯示男，其它不回顯
if(條件表示式){
程式碼塊; //0條到多條可執行語句，含義是當【條件表示式】返回值為true時執行這裡，如果返回
為false這裡不執行。如果程式碼塊中只有一條語句，則{}可以省略 }
Scanner sc = new Scanner(System.in); System.out.println(“請輸入性別:true/false”); boolean bb = sc.nextBoolean();
if (bb) {//可以寫成if(bbtrue)
//如果if(bbfalse){}可以簡寫為if(!bb){}
System.out.println(“您輸入的是男”); }
System.out.println(“程式執行結束!”);
語法規則2:一定會執行其中的一個分支，不可能出現都不執行或者都執行的情況
要求使用者輸入學生性別，如果輸入true則顯示男，其它顯示女
1 2 3 4 5 6 7 8 9
Scanner sc = new Scanner(System.in); System.out.println(“請輸入性別:true/false”); boolean bb = sc.nextBoolean();
if (bb) {
System.out.println(“您輸入的是男”); }else {
System.out.println(“您輸入的是女”); }
System.out.println(“程式執行結束!”);
語法3:多個條件多個分支
1 2 3 4 5 6 7
if(條件表示式1){ 程式碼塊1;
}else if(條件表示式2){ //允許多次出現 程式碼塊2;
}else{ //當上面所有條件都不成立時執行 程式碼塊n;
}
需求:要求輸入學生成績(假設成績都是整數)，如果>85顯示優秀，如果>70顯示良好，如果>60顯示 及格，否則顯示不及格
System.out.println(“請輸入學生成績:”);//提示資訊
Scanner sc = new Scanner(System.in);//構建Scanner物件
int score = sc.nextInt();//阻塞當前程式的執行，等待使用者輸入int型別的資料 //首先對使用者錄入的資料進行合法性驗證
if(score>=0 && score<=100) {
if (score > 85) {
System.out.println(“優秀”); //當其中一個語句塊執行後則立即跳出if結構，不
會繼續執行後續判斷
} else if (score > 70) //如果語句塊只有一條語句則{}可以省略 // 第二個條件實際上是一個複合條件 !(score>85) && score>70
System.out.println(“良好”); else if (score >= 60)
System.out.println(“及格”); else //當所有條件都不成立時執行的語句
System.out.println(“不及格”); }else {
System.out.println(“輸入的成績不合法!”); }
System.out.println(“執行結束”);
if(條件表示式){
程式碼塊1; //0條到多條可執行語句，含義是當【條件表示式】返回值為true時執行這裡
}else{
程式碼塊2; //當條件為true時執行[程式碼塊1]，否則執行【程式碼塊2】，不可能出現都執行或者都不
執行的情況
}
if/if…else/if…else if…else允許巢狀 需求:要求輸入學生成績(假設成績都是整數)和學生性別，如果男生>60顯示你是個豬?，如果小於
60顯示你連豬都不如;如果女生>60顯示還可以阿，如果小於60顯示繼續加油啊
public class Test1 {
public static void main(String[] args) {
int score = 0;// 定義臨時變數使用者儲存學生成績 System.out.println(“請輸入學生成績”);
Scanner sc = new Scanner(System.in);
score = sc.nextInt();// 條件中要求學生成績必須為整數
// 由於sc.nextInt不能消費掉末尾的回車符，所以下一個nextLine則不能接收到資料 if (sc.hasNextLine())
sc.nextLine();
boolean sex = true;// 用於儲存性別 System.out.println(“請輸入學生性別”);
String ss = sc.nextLine();// 讀取一行資料
sex = “男”.equals(ss);
// 驗證程式的輸入邏輯是否正確
System.out.println(“您輸入的學生成績為:” + score + “,性別為:” + sex); if (sex) {
// 男生 , 如果男生>60顯示你是個豬?，如果小於60顯示你連豬都不如 if (score > 60)
System.out.println(“你是個豬?”); else if (score < 60)
System.out.println(“你連豬都不如”); //注意:else不是必須的,else的含義是score<=60
} else {
// 女生,>60顯示還可以阿，如果小於60顯示繼續加油啊 if(score>60)
} }
}
System.out.println(“還可以阿”); else if(score<60)
System.out.println(“繼續加油啊”);
標準輸出
System.out.println(obj) 引數obj可以是任意型別的資料，實際上其它型別的資料是自動轉換為字串類 型進行輸出顯示
鍵盤資料錄入
Scanner用於實現接收使用者的鍵盤錄入資料
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();從鍵盤上接受一個使用者錄入的整數
1 Scanners=newScanner(System.in);//構建一個Scanner物件用於接收使用者的鍵盤錄入數 據
2 Stringss=s.nextLine();//讀取使用者輸入的一行資料，以回車作為標誌 3 System.out.println(“input:”+ss+“1111”);
類似的方法還有用於接收浮點數的s.nextDouble等多種
開關分支語言
多個分支的等值判斷時，使用switch比if使用方便
switch (表示式) { case 值1:
操作 1 的語句; case 值2:
操作 2 的語句;
…
case 值n :
操作 n 的語句; default:
break;
break;
break;
}
預設語句;
int birth = 1972;
// 獲取當前的年份
int year = new Date().getYear() + 1900;// new Date()用於獲取當前機器的日期， getYear用於獲取當前日期的年份值
// 10歲以下稱黃口,20歲以下稱舞象之年,男子20歲稱弱冠，30歲稱而立之年。40歲稱不惑之年。 // 50歲稱知命之年。60歲稱花甲或耳順之年。70歲稱古稀之年。80歲稱杖朝之年
// 80至90歲稱耄耄之年。100歲樂期頤
int res = (year - birth) / 10; //注意這裡是整除計算—技巧 18/10=1
switch (res) {
case 0:
System.out.println(“黃口”); //break用於實現跳出switch結構，否則繼續向後執行直到break或者switch結構結束 break;
case 1: System.out.println(“舞象之年”); break;
case 2: System.out.println(“弱冠”); break;
case 3: System.out.println(“而立之年”); break;
//剩餘省略… default:
System.out.println(“樂期頤”);
break; //由於沒有後續語句，所以break可以省略
}
Scanner s = new Scanner(System.in);// 構建一個Scanner物件用於接收使用者的鍵盤錄入數 據
int ss = s.nextInt();// 接收使用者輸入的整數,如果輸入資料的格式不正確，則報錯中斷程式; 如果使用者不輸入資料則一直等待使用者輸入
System.out.println(“input:” + ss + “~~~~”);
重點的語法規則:switch後面的表示式允許的資料型別? 允許byte\short\int，但是不允許long型別
允許字元型別和字串型別[特殊點，要求JDK1.7+],究其本質是比較字串的hashcode值
String str=“12”;
switch (str) {
case “0”:
System.out.println(“黃口”); //break用於實現跳出switch結構，否則繼續向後執行直到break或者
switch結構結束 break;
}
case “1”: System.out.println(“舞象之年”); break;
case “2”: System.out.println(“弱冠”); break;
case “3”: System.out.println(“而立之年”); break;
default:
System.out.println(“樂期頤”);
break; //由於沒有後續語句，所以break可以省略
String和列舉型別的具體實現延遲到面向物件章節之後 列舉型別
需求:輸入學生成績，如果>=80顯示優秀，如果>=60顯示及格，否則顯示不及格
1 2 3 4 5 6 7 8 9
10
int score=87;
switch(score){
case 100:
case 99:
…
case 80:
System.out.println(“優秀!”);
break;
case …
}
簡化程式碼:
1 2 3 4 5 6 7 8
public class Test2 {
public static void main(String[] args) {
System.out.println(“請輸入學生成績:”); Scanner sc=new Scanner(System.in); int score=sc.nextInt();
if(score>=0 && score<=100) {
int level=score/10;
switch (level) {
迴圈結構
迴圈就是重複做某一件事情。在Java程式中，迴圈控制即在某一情況下，控制程式重複執行某一條或多 條語句，直到遇到終止條件為止
迴圈語句也稱迭代語句，在Java語言中存在的while、for和do-while迴圈語句 while迴圈
while是Java中最基本的迴圈語句，滿足條件才執行迴圈體，如果不滿足條件則不執行。所以有可能迴圈 體一次都不執行。
語法格式: while (繼續迴圈的條件) { 迴圈所執行的程式碼; }
1 2 3 4 5 6 7 8 9
10
public class Test3 {
public static void main(String[] args) {
int res = 0;// 累加器
int k = 1;// 用於控制迴圈次數 while (k <= 100) {
res += k++;//這裡等價於res=res+k;k++; }
System.out.println(“1+2+3+…+100=” + res);
}
}
用while迴圈接收使用者輸入小明的成績，如果使用者輸入不合法就反覆輸入，直到正確為止
} }
case 10:
case 9:
case 8:
System.out.println(“優秀”);
break;
case 7:
case 6: System.out.println(“及格”); break;
default: System.out.println(“不及格”); break;
} }else {
System.out.println(“輸入的成績不合法!”); }
1 2 3 4 5 6 7
public class Test3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int score = -1;
while (score < 0 || score > 100) {
System.out.println(“請輸入小明成績:”); String ss = sc.nextLine();
假如投資的年利率為5%，試求從1000塊增長到5000塊，需要花費多少年 猜年齡遊戲。允許使用者最多嘗試3次，3次都沒猜對的話，就直接退出，如果猜對了，列印恭喜資訊並退
出
do-while迴圈
do-while 迴圈執行某些語句，直到指定的條件為假。此迴圈確保迴圈體至少執行一次。 語法格式: do{迴圈所執行的邏輯;}while(繼續迴圈的條件); 樣例:計算1+2+3+…+100=?
public class Test4 {
public static void main(String[] args) {
} }
int res = 0;
int k = 1;
do {
res+=k++;
} while (k <= 100);
System.out.println(“1+2+3+…+100=”+res);
for迴圈
for 迴圈主要用於按預定的次數執行語句或語句塊
語法: for(語句1，一般用於初始化迴圈控制變數; 語句2，是迴圈繼續執行的條件; 語句3，是每次循 環執行結束後必須執行的語句){ 迴圈體語句; }
樣例:計算1+2+3+…+100=?
try {
score = Integer.parseInt(ss);
if (score < 0 || score > 100) {
System.out.println(“要求成績值應該0-100之間”); }
} catch (Exception e) { System.out.println(“請輸入合法的整數成績值”);
} }
System.out.println(“小明的成績為:” + score); }
}
輸出直角三角形 一張紙的厚度大約是0.08mm，對摺多少次之後能達到珠穆朗瑪峰的高度(8848.13米)
三種迴圈的選擇
1、如果不能提前預知迴圈次數，則使用while或者do/while迴圈，而for迴圈一般用在可提前預知迴圈次 數的場景下
2、while迴圈可以出現一次都不執行的情況，但是do/while迴圈無論如何迴圈體都會被執行一次 需求:輸出九九乘法表
1 2 3 4 5 6 7 8 9
10
public class Test7 {
public static void main(String[] args) {
} }
for(int i=1;i<=9;i++) {//控制行數
for(int k=1;k<=i;k++) {//控制每行的列數
System.out.print(k+""+i+"="+(ik)+"\t");
}
System.out.println();
}
迴圈中使用的跳轉語句
Java提供了三種跳轉語句:break、continue以及return，用來強制轉移程式執行的順序
break
break語句除了與switch結合使用外，還用來強制中斷當前的迴圈，不再執行迴圈體中break後面的語句 而退出迴圈。譬如在後續將學到從資料庫裡迴圈取出資料，用來驗證使用者的使用者名稱是否正確。如果當用 戶名符合某一條資料時，就需要用到break語句來結束當前的迴圈驗證
continue
continue語句的功能是，在迴圈語句中，當碰到continue時，將不再執行迴圈體continue之後的語句， 而重新判斷迴圈控制的條件，繼續迴圈，直到迴圈條件的值為假時退出迴圈
例如:用continue語句來計算1~10中所有偶數之和
1 2 3 4 5 6
7 8 9
public class Test6 {
public static void main(String[] args) {
//
效
}
int res = 0;
for (int k = 1; k <= 100; k++)
res += k;
System.out.println(k); 報錯:變數k是在表示式1上宣告的，只能在for迴圈內部有
System.out.println(“1+2+3+…+100=” + res);
}