|
1 基本結(jié)構(gòu)Java程序基本結(jié)構(gòu)包括包、類、main（）主方法、標識符、關(guān)鍵字、語句和注釋等。 Java語言中主方法的寫法固定，除了可以修改形參String[]args為String args[]，不可改變語句public static void main（String args[]）的任何部分. 1.1 標識符與關(guān)鍵字Java語言的標識符是字母、數(shù)字、下劃線和美元符號組成，第一個字符不可以為數(shù)字；標識符不可以是Java的關(guān)鍵字和保留字；標識符區(qū)分大小寫。 類名規(guī)范要首字母大寫且后面每個單詞首字母大寫；變量名規(guī)范要首字母小寫且后面每個單詞首字母大寫；方法名規(guī)范同變量名規(guī)范。 1.2 常量和變量常量是固定不變的量，分類有字符串常量（雙引號引起的部分）、整數(shù)常量（沒有小數(shù)點的數(shù)）、浮點數(shù)常量（有小數(shù)點的數(shù)）、字符常量（單引號引起的單個字符，單引號中間必須有且僅有一個字符）、布爾常量（True、False兩種取值）、空常量（nul，代表沒有任何數(shù)據(jù)，不能夠直接放在println方法中）。 1 package come_one;
2
3 public class demoone {
4 public static void main(String[] args) {
5 //字符串常量 字符數(shù)目可任意
6 System.out.println("Hello,World!!");
7 System.out.println("");
8 System.out.println("-^_^-");
9
10 //整數(shù)常量
11 System.out.println(100);
12 System.out.println(-100);
13
14 //浮點數(shù)常量
15 System.out.println(3.14);
16
17 //字符常量
18 System.out.println('0');
19 System.out.println(' ');
20 System.out.println('0');
21
22 //布爾常量
23 System.out.println(true);
24 System.out.println(false);
25
26 //空常量不能直接打印輸出,以下為錯誤寫法
27 System.out.println();
28 }
29 }
變量是程序運行期間內(nèi)容可以發(fā)生改變的量。 創(chuàng)建一個變量并且使用的格式為：數(shù)據(jù)類型 變量名稱； 賦值變量的格式為：變量名稱 = 數(shù)據(jù)值； 一步到位的格式為：數(shù)據(jù)類型 變量名稱 = 數(shù)據(jù)值； 1 package come_one;
2
3 public class demotwo {
4 public static void main(String args[]) {
5 //創(chuàng)建一個變量:數(shù)據(jù)類型 變量名稱
6 int number1;
7 //變量中存入一個數(shù)據(jù)：變量名稱=數(shù)據(jù)值
8 number1 = 100;
9 //打印變量
10 System.out.println(number1);
11
12 //一步走:數(shù)據(jù)類型 變量名稱=數(shù)據(jù)值
13 int number2 = 20;
14 System.out.println(number2);
15
16 //改變變量值
17 number2 = 99;
18 System.out.println(number2);
19 }
20 }
1.3 數(shù)據(jù)類型數(shù)據(jù)類型有基本數(shù)據(jù)類型和引用數(shù)據(jù)類型，基本數(shù)據(jù)類型有整數(shù)型（byte，short，int，long）、浮點型（float，double）、字符型（char）、布爾型（boolean），引用數(shù)據(jù)類型包含字符串、數(shù)組、類、接口、lambda。 注意1：字符串不是基本類型而是引用類型； 浮點類型是一個近似值，并非精確值； 數(shù)據(jù)范圍與字節(jié)數(shù)不一定相關(guān)，如float數(shù)據(jù)范圍比long更加廣泛，但float是4字節(jié)，long是8字節(jié)。 浮點數(shù)中默認類型為double，如果需要使用float類型則需要加上后綴F。 如果是整數(shù)默認類型為int，如果需要之用long類型，則需要加上后綴L，如System.out.println（100L）中輸出為長整數(shù)類型。 變量賦值數(shù)據(jù)不能夠超出數(shù)據(jù)類型范圍，否則會報錯。 注意2：變量的創(chuàng)建中變量名稱不重復(fù)； 對float和long類型而言，字母后綴F和L不能丟； 沒有進行賦值的變量不可以直接使用； 使用byte或short類型的變量時右側(cè)數(shù)據(jù)值不能夠超過左側(cè)數(shù)據(jù)類型的范圍； 變量使用不能夠超過作用域的范圍（作用域是從變量定義的一行開始，直到直接所屬的大括號結(jié)束為止）； 可以通過一個語句來創(chuàng)建多個變量，可創(chuàng)建變量后各自賦值或者創(chuàng)建變量時賦值。 編譯器的兩個優(yōu)化：對于byte/short/char類型的數(shù)據(jù)如果右側(cè)賦值的數(shù)據(jù)沒有超過范圍，那么javac編譯器將會自動隱含地補上一個(byte)(short)(char).如果沒有超過左側(cè)范圍編譯器補上則強制轉(zhuǎn)換，如果右側(cè)超過左側(cè)范圍，那么編譯器會直接報錯。在給變量賦值的時候，如果右側(cè)的表達式全為常量沒有任何變量，那么編譯器javac會直接將若干個常量表達式計算得到結(jié)果（如 short res = 5+8；//等號右邊全部是常量，編譯完成后得到的class字節(jié)碼文件中相當于short res = 13；這就不需要程序運行耗費cpu），但是表達式中有變量參與時則不能進行優(yōu)化。（short a=5;short b=8;short res=a+b;這是錯誤寫法，左側(cè)需要int類型。）
1 package come_one;
2 //import java.util.*;
3 public class demotwo {
4 public static void main(String[] args) {
5 //創(chuàng)建一個變量:數(shù)據(jù)類型 變量名稱
6 int number1;
7 //變量中存入一個數(shù)據(jù)：變量名稱=數(shù)據(jù)值
8 number1 = 100;
9 //打印變量
10 System.out.println(number1);
11
12 //一步走:數(shù)據(jù)類型 變量名稱=數(shù)據(jù)值
13 int number2 = 20;
14 System.out.println(number2);
15
16 //改變變量值
17 number2 = 99;
18 System.out.println(number2);
19
20 //浮點型與雙精度類型
21 float number3 = 30.0F;
22 System.out.println(number3);
23 double number4 = 100.0;
24 System.out.println(number4);
25
26 //短型與長整型
27 short number5 = 30;
28 System.out.println(number5);
29 long number6 = 30000000000L;
30 System.out.println(number6);
31
32 //字節(jié)類型
33 byte number7 = 20;
34 System.out.println(number7);
35
36 //字符類型
37 char hanzi = '中';
38 System.out.println(hanzi);
39
40 //布爾類型
41 boolean var1 = true;
42 System.out.println(var1);
43 boolean var2 = var1;
44 }
45 }
2 數(shù)據(jù)類型轉(zhuǎn)換數(shù)據(jù)類型不一樣時會發(fā)生數(shù)據(jù)類型轉(zhuǎn)換。數(shù)據(jù)類型轉(zhuǎn)換有自動類型轉(zhuǎn)換和強制類型轉(zhuǎn)換兩種。 自動類型轉(zhuǎn)換的特點是代碼不需要特殊處理能夠自動完成，規(guī)則是數(shù)據(jù)范圍從小到大。 強制類型轉(zhuǎn)換的特點是代碼需要進行特殊的格式處理不能夠自動完成，格式是：范圍小的類型（范圍小的變量名） 范圍小的變量名 = （范圍小的類型）原本范圍大的數(shù)據(jù)。 注意事項：強制類型不推薦使用，因為有可能發(fā)生精讀損失、數(shù)據(jù)溢出。byte/short/char類型的數(shù)據(jù)可以發(fā)生數(shù)學運算，在運算時首先成為int類型再計算。布爾類型不能發(fā)生數(shù)據(jù)轉(zhuǎn)換。 1 package come_one;
2
3 public class demo03 {
4 public static void main(String args[]) {
5
6 //數(shù)據(jù)類型轉(zhuǎn)換服從數(shù)據(jù)范圍從小到大
7 System.out.println(1024);//int類型
8 System.out.println(3.14);//double類型
9
10 //左邊long類型，右邊默認int類型，左右不一樣
11 //將int常量放到long變量容器中存儲
12 long num1 = 100;
13 System.out.println(num1);//100
14
15 //左側(cè)是double類型，有測是float類型，左右不一樣
16 //將float類型量放入double類型變量
17 double num2 = 1.5F;
18 System.out.println(num2);
19
20 //左邊是float類型，右邊是long類型
21 //數(shù)據(jù)類型 ：long-》float
22 float num3 = 30L;
23 System.out.println(num3);
24
25 //等號左邊為int，右邊為long long變int不是從小到大
26 //不符合從小到大不能夠自動類型轉(zhuǎn)換
27 //范圍小的類型 范圍小的變量名 = (范圍小的類型) 原本范圍大的數(shù)據(jù)
28 int num4 = (int)100L;
29 System.out.println(num4);
30
31 //發(fā)生數(shù)據(jù)溢出
32 int num5 = (int)6000000000L;//1705032704
33 System.out.println(num5);
34
35 //發(fā)生精度損失
36 int num6 = (int)3.5;
37 System.out.println(num6);//不是四舍五入，小數(shù)位舍棄
38
39 char zifu1 = 'Z';
40 System.out.println(zifu1 + 1);
41 //char類型進行數(shù)學運算時char會被翻譯成為數(shù)字
42
43 byte num7 = 50;
44 byte num8 = 40;
45 //下語句報錯，byte相加變成int+int
46 //byte res = num7 + num8;
47 int res = num7 + num8;
48 System.out.println(res);
49
50 short num9 = 10;
51 //int強制轉(zhuǎn)換int，必須保證邏輯上真實大小本來沒有超過short范圍
52 short res2 = (short) (num9 + num8);
53 }
54 }
**128個ASCII碼表關(guān)鍵記憶** 48對應(yīng)'0',65對應(yīng)'A'，97對應(yīng)'a'。除ASCII碼外，碼表還有Unicode萬國碼表。
3 運算符運算符是進行特定操作的符號，表達式是運算符連接的式子。 運算符種類有算術(shù)運算符（+，-，*，/，%，++）、賦值運算符、比較運算符、邏輯運算符和三元運算符。 3.1 算術(shù)運算符注意事項：一旦運算中有不同類型的數(shù)據(jù)，那么結(jié)果將會是數(shù)據(jù)類型范圍大的那種。 加號'+’的三種用法：（1）對數(shù)值而言是加法；（2）對字母char類型而言在計算之前會提升成為int然后再計算（ASCII碼表和Unicode表）；（3）對字符串String（首字母大寫）并不是關(guān)鍵字而言，加號代表字符串連接操作。任何數(shù)據(jù)類型和字符串進行連接的時候結(jié)果都會變成字符串。 只有變量才能使用自增自減運算符，常量不能使用自增自減。自增自減運算可以單獨使用，不與其他任何操作混合，自己獨立成為一個步驟；混合使用時可以和其他操作如賦值混合或與打印操作混合。單獨使用時前++和后++結(jié)果無區(qū)別?；旌鲜褂脮r前++是變量馬上+1拿著結(jié)果使用，后++是先使用變量后+1。 3.2 賦值運算符賦值運算符包含基本賦值運算符'=’和復(fù)合賦值運算符（+=，-=，/=，*=，%=）。 只有變量才能使用賦值運算符，常量不能進行賦值。復(fù)合賦值運算符中隱含了強制類型轉(zhuǎn)換。 3.3 比較運算符比較運算符主要用于進行數(shù)值大小關(guān)系判斷，其結(jié)果一定是Boolean值要么true要么false； 如果進行多次判斷，則不能連著寫如1<x<3這種數(shù)學形式不能直接寫，而是：1 < x && x < 3。 3.4 邏輯運算符邏輯運算符有與（并且，&&）、或（或者，||）、非（取反，?。┻@三種運算符。 與和或具有短路效果，根據(jù)左邊已經(jīng)可以判斷得到最終結(jié)果，那么右邊的代碼將不再執(zhí)行。 邏輯運算符只能用于Boolean型，與、或需要左右各自有一個Boolean值，但是取反只要有唯一的一個Boolean值，與或兩種運算符如果有多個條件可以連續(xù)寫。 3.5 三元運算符一/二/三元運算符的區(qū)別需要數(shù)據(jù)的數(shù)目不同，一元運算如自增自減、取反，二元運算如加減乘除、賦值。 三元運算符的格式是：數(shù)據(jù)類型 變量名稱 = 條件判斷 ？ 表達式A：表達式B； 首先判斷條件是否成立，判斷成立則將表達式A值賦值左側(cè)變量，如果不成立則將表達式B值賦值左側(cè)變量，二者選其一。 注意：需要同時保證表達式A和表達式B都符合左側(cè)數(shù)據(jù)類型的要求。 三元運算符的結(jié)果必須被使用，不能夠單獨成語句。
1 package come_one;
2
3 public class demo04 {
4 public static void main(String args[]) {
5 //算術(shù)運算符
6 int a = 30;
7 int b = 20;
8 System.out.println(a + b);
9 System.out.println(a - b);
10 System.out.println(a * b);
11 System.out.println(a / b);
12 System.out.println(a % b);
13 System.out.println(a++);
14 System.out.println(a);
15 //int + double -> double + double = double
16 System.out.println(a + 2.5);
17 //混合使用
18 int result = --a;
19 System.out.println(result);
20
21 //字符串類型變量
22 String str1 = "Hello";
23 String str2 = "World";
24 System.out.println(str1 + str2);
25 //優(yōu)先級問題 String > int
26 //String + int + int = String + int = String
27 System.out.println("Java"+1+5);
28 System.out.println("Java"+(1+5));
29
30 //賦值運算符
31 int num1 = 20;
32 num1 -= 2;
33 System.out.println(num1);
34 num1 += 2;
35 System.out.println(num1);
36 num1 /= 2;
37 System.out.println(num1);
38 num1 *= 2;
39 System.out.println(num1);
40 num1 %= 8;
41 System.out.println(num1);
42
43 //比較運算符
44 //《 》 《= 》= == ！=
45 System.out.println(10 > 5);
46 System.out.println(10 < 5);
47 System.out.println(10 != 5);
48 System.out.println(10 <= 5);
49 System.out.println(100 == 100);
50
51 //邏輯運算符
52 System.out.println(true && false);
53 System.out.println(3 < 4 && 100 != 100);
54 System.out.println(true || false);
55 System.out.println(3 < 4 || 100 != 100);
56 System.out.println(!true);
57
58 //三元運算符
59 int max;
60 a = 20;
61 b = 15;
62 max = (a > b) ? a : b;
63 System.out.println("最大值："+max);
64 }
65 }
4 方法入門方法是將一個功能抽取出來，把代碼單獨定義在一個大括號內(nèi)，形成一個單獨的功能，當需要這個功能的時候就可以去調(diào)用，以此實現(xiàn)代碼的復(fù)用性、代碼的冗余性問題。方法是若干語句的功能集合，包含參數(shù)與返回值。參數(shù)是進入方法的數(shù)據(jù)，返回值是方法中出來的數(shù)據(jù)。 方法定義的格式：public static void 方法名稱（）{ 方法體 }。方法名稱的命名規(guī)則與變量命名規(guī)則相同采用小駝峰式，方法體是大括號中可以包含任意條語句。定義方法的完整格式是：修飾符（public static） 返回值類型（方法最終產(chǎn)生的數(shù)據(jù)結(jié)構(gòu)的類型） 方法名稱（參數(shù)類型 參數(shù)名稱，...）{方法體 + return 返回值；} return作用：第一是停止當前方法，第二是將后面的返回值還給調(diào)用處。返回值是方法執(zhí)行后最終產(chǎn)生的數(shù)據(jù)結(jié)果。
調(diào)用方法的格式：方法名稱（）； 方法調(diào)用過程是找到方法-參數(shù)傳遞-執(zhí)行方法體-帶著返回值回到方法的調(diào)用處 方法調(diào)用有單獨調(diào)用、打印調(diào)用、賦值調(diào)用三種。void返回值類型的方法只能夠單獨調(diào)用不能夠賦值調(diào)用和打印調(diào)用。
方法參數(shù)情況可以分為有參數(shù)和無參數(shù)兩種，有參數(shù)是指小括號中有內(nèi)容；無參數(shù)是小括號中留空，一個方法不需要任何數(shù)據(jù)條件自己就能獨立完成任務(wù)。 方法返回值可以分為有返回值和無返回值，根據(jù)需求決定。
注意事項：
方法定義的先后順序無所謂，方法的定義不能產(chǎn)生嵌套包含關(guān)系，方法定義后不會執(zhí)行如果要執(zhí)行則要進行方法的調(diào)用。
return后面的返回值必須和方法名稱前面的返回值類型保持對應(yīng)。方法定義在類當中，不能在方法中定義方法（不能嵌套）。
對于return沒有返回值的方法，不能寫return后面的返回值，只能return自己（即“return；”）。
方法中最后一行的return可以省略不寫。一個方法中可以有多個return，但是必須保證同時只有一個return會執(zhí)行到，兩個return不能連寫。
public class demo05 {
public static void main(String args[]) {
//將菜的過程用代碼體現(xiàn)出來，但是這么多代碼無法分清楚執(zhí)行的對象是誰
//可以將以下步驟分成四個主要對象，每個執(zhí)行內(nèi)容可以定義一個方法
//農(nóng)民伯伯
System.out.println("播種");
System.out.println("澆水");
System.out.println("施肥");
System.out.println("除蟲");
System.out.println("收割");
System.out.println("賣給小商販");
//小商販
System.out.println("運輸?shù)睫r(nóng)貿(mào)市場");
System.out.println("抬高價格");
System.out.println("吆喝");
System.out.println("賣給廚子");
//廚子
System.out.println("洗菜");
System.out.println("切菜");
System.out.println("炒菜");
System.out.println("裝盤");
//我
System.out.println("吃");
}
package come_one;
public class demo05 {
public static void main(String args[]) {
//將菜的過程用代碼體現(xiàn)出來，但是這么多代碼無法分清楚執(zhí)行的對象是誰
//可以將以下步驟分成四個主要對象，每個執(zhí)行內(nèi)容可以定義一個方法
//下面采用方法的途徑來實現(xiàn)調(diào)用
farmer();
saler();
cook();
me();
}
//農(nóng)民伯伯
public static void farmer() {
System.out.println("播種");
System.out.println("澆水");
System.out.println("施肥");
System.out.println("除蟲");
System.out.println("收割");
System.out.println("賣給小商販");
}
//小商販
public static void saler() {
System.out.println("運輸?shù)睫r(nóng)貿(mào)市場");
System.out.println("抬高價格");
System.out.println("吆喝");
System.out.println("賣給廚子");
}
//廚子
public static void cook() {
System.out.println("洗菜");
System.out.println("切菜");
System.out.println("炒菜");
System.out.println("裝盤");
}
//我
public static void me() {
System.out.println("吃");
}
}
package come_two; public class demo01 { public static void main(String args[]) { //打印調(diào)用 System.out.println(addTwonum(10,20)); System.out.println("---------------"); //單獨調(diào)用 addTwonum(10,20); System.out.println("---------------"); //賦值調(diào)用 int sum = addTwonum(10,20); System.out.println("變量的值："+sum); } public static int addTwonum(int a,int b) { System.out.println("方法執(zhí)行！"); int sum; sum = a + b; return sum; } }
方法重載（Overload）： 方法重載是方法名稱相同但是參數(shù)列表不同，好處是只需要記住一個方法名稱就可以實現(xiàn)類似的功能。 方法重載與下列因素相關(guān)：參數(shù)個數(shù)不同，參數(shù)類型不同（可以強制轉(zhuǎn)換或自動轉(zhuǎn)換），參數(shù)類型順序不同。 方法重載與下列因素無關(guān)：參數(shù)名稱，方法的返回值類型 package come_two; public class demo02 { public static void main(String args[]) { System.out.println(sum(10, 10, 10, 10)); System.out.println(sum(10, 10, 10)); System.out.println(sum(10, 10)); } //方法重載：可實現(xiàn)多個參數(shù)的使用,名稱相同但是參數(shù)列表不同 public static int sum(int a,int b) { return 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; } } package come_two; //方法重載練習1 //比較兩個數(shù)據(jù)是否相等 //參數(shù)類型為2個byte，2個short，2個int，2個long，并在main中測試 public class demo02 { public static void main(String arg[]) { byte a = 10; byte b = 20; System.out.println(isSame(a, b)); System.out.println(isSame((short)10, (short)20)); System.out.println(isSame(15,15)); System.out.println(isSame(100L, 100L)); } public static boolean isSame(byte a, byte b) { boolean same; if(a == b) { same = true; }else { same = false; } return same; } public static boolean isSame(short a, short b) { boolean same = a == b ? true:false; return same; } public static boolean isSame(long a, long b) { return a == b; } public static boolean isSame(int a, int b) { if(a == b) { return true; }else { return false; } } }
5 流程與語法結(jié)構(gòu)流程有三種：順序、循環(huán)、選擇結(jié)構(gòu)。 順序結(jié)構(gòu)：開始->步驟A->步驟B->步驟C->結(jié)束，按箭頭順序操作執(zhí)行。 判斷語句（選擇結(jié)構(gòu)）：單if語句，if-else語句，復(fù)合if..else if... else語句，三元運算符和if-else語句比較。 選擇語句（switch）：每種情況用case表示，不滿足則用default。switch后面小括號中僅能是下列數(shù)據(jù)類型（基本數(shù)據(jù)類型：byte/short/char/int;引用數(shù)據(jù)類型：String字符串、enum枚舉）。switch語句前后順序可以顛倒，而且break語句可以省略，匹配哪一個case就從哪一個位置向下執(zhí)行，直到遇到break或者整體結(jié)束為止。
package come_one;
//單if語句
public class demo06 {
public static void main(String args[]) {
System.out.println("今天天氣不錯，正在遛馬路，突然發(fā)現(xiàn)一個快樂的地方：網(wǎng)吧");
//int age = 16;
//條件滿足執(zhí)行語句體，不滿足則跳過
int age = 18;
if(age >= 18) {
System.out.println("進入網(wǎng)吧，開始high！");
System.out.println("遇到了一群豬隊友，開始罵街");
System.out.println("感覺不舒服，結(jié)賬走人");
}
System.out.println("回家吃飯");
}
}
package come_one;
//if-else語句
public class demo06 {
public static void main(String args[]) {
int num = 666;
if(num % 2 == 0) {
System.out.println(num+"為偶數(shù)");
}else {
System.out.println(num+"為奇數(shù)");
}
}
}
package come_one;
//if-else if - else復(fù)合語句
public class demo06 {
public static void main(String args[]) {
int x = 2;
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);
}
}
package come_one;
//使用三元運算符和標準的if-else語句分別實現(xiàn)兩個數(shù)字的最大值
public class demo06 {
public static void main(String args[]) {
int a = 20;
int b = 30;
//三元運算符
int max = a > b ? a : b;
int max1;
if(a > b) {
max1 = a;
}else {
max1 = b;
}
System.out.println(max);
System.out.println(max1);
}
}
package come_one;
//switch語句
public class demo06 {
public static void main(String args[]) {
int num = 5;
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可以省略，但建議保留
}
}
}
循環(huán)結(jié)構(gòu)是滿足循環(huán)條件情況下反復(fù)執(zhí)行某一段代碼即循環(huán)體，在合適的時候?qū)⒀h(huán)條件修改為False而結(jié)束循環(huán)。循環(huán)結(jié)構(gòu)的基本組成部分可以分為初始化語句（在循環(huán)開始最初執(zhí)行，而且只做唯一一次）、條件判斷、循環(huán)體（重復(fù)做的若干行語句，事件內(nèi)容）、步進語句（每次循環(huán)之后進行的掃尾工作，每次循環(huán)結(jié)束后都要執(zhí)行一次）。 循環(huán)語句有for循環(huán)語句，結(jié)構(gòu)為for（初始化表達式；布爾表達式；步進表達式）+ 循環(huán)體。
while循環(huán)有一個標準格式還有一個擴展格式。標準格式是while（條件判斷）+循環(huán)體，擴展格式是初始化語句+while（條件判斷）+循環(huán)體（后跟步進語句）。
do-while語句的格式是do+循環(huán)體+while（條件判斷）；程序遇到do則無條件執(zhí)行循環(huán)體內(nèi)容，執(zhí)行完后判斷條件是否成立。擴展格式為初始化語句+do+循環(huán)體（后跟步進語句）+while（條件判斷）； package come_one;
public class demo07 {
public static void main(String args[]) {
//for語句
for(int i = 1;i <= 10;i++) {
System.out.println(i+"我錯了！請原諒我");
}
//while語句擴展格式
int i = 1;
while(i<=10) {
System.out.println(i+"-我錯了！請原諒我");
i++;
}
//do-while循環(huán)
int j = 1;
do {
System.out.println(j+"--我錯了！請原諒我");
j++;
}while(j <= 10);
}
}
三種循環(huán)的區(qū)別： 1.如果條件判斷不滿足，那么for循環(huán)和while循環(huán)將會執(zhí)行0次，但是do-while循環(huán)會執(zhí)行至少一次。 2.for循環(huán)的變量在小括號中定義，是局部變量，只有在循環(huán)內(nèi)部才可以使用。while循環(huán)和do-while循環(huán)的初始化語句在外面，出循環(huán)后可以繼續(xù)使用。 ***補充： break關(guān)鍵字可用于switch中，一旦執(zhí)行整個switch語句立刻結(jié)束。還可以應(yīng)用于循環(huán)語句中，一旦執(zhí)行整個循環(huán)語句立刻結(jié)束，打斷循環(huán)。次數(shù)確定的場景可以用for循環(huán)，否則可以用while循環(huán)。continue關(guān)鍵字一旦執(zhí)行立刻跳過當前次循環(huán)剩余內(nèi)容馬上開始下一次循環(huán)。
6 數(shù)組數(shù)組是一種容器，可以同時存放多個數(shù)據(jù)值。 數(shù)組的特點：數(shù)組是一種引用的數(shù)據(jù)類型；數(shù)組當中的多個數(shù)據(jù)，類型必須統(tǒng)一；數(shù)組的長度在程序運行期間不可改變。 數(shù)組的初始化是在內(nèi)存中創(chuàng)建一個數(shù)組并且向其中賦予一些默認值。初始化方式可以是動態(tài)初始化（指定長度）和靜態(tài)初始化（指定內(nèi)容）、省略格式。雖然靜態(tài)初始化沒有直接告訴長度，但是根據(jù)大括號里面元素具體內(nèi)容也可以自動計算出長度。靜態(tài)初始化和動態(tài)初始化可以拆分為兩個步驟，具體寫代碼表達。靜態(tài)初始化一旦使用省略格式則不能夠拆分為兩個步驟。動態(tài)初始化數(shù)組時元素自動擁有一個默認值，整數(shù)類型默認0，浮點類型默認0.0，字符類型默認\u0000，布爾類型默認false，引用類型默認null。靜態(tài)初始化其實也有默認值過程，只不過系統(tǒng)自動馬上將默認值替換成為了大括號中具體數(shù)值。 直接打印數(shù)組名稱得到的是數(shù)組對應(yīng)的內(nèi)存哈希地址。 兩個數(shù)組的引用可以用arrayA = arrayB實現(xiàn)，即將arrayB的地址傳送給arrayA，引用后A或B修改會影響兩者。 數(shù)組索引編號從0開始到數(shù)組長度-1為止，訪問數(shù)組元素的時候索引編號不存在將會發(fā)生數(shù)組索引越界異常ARRAYINDEXOUTOFBOUNDSEXCEPTION，原因是索引編號錯誤，通過修改正確索引編號可解決問題。 所有的引用類型變量都可以賦值為null值，但是代表其中什么都沒有。數(shù)組必須進行new初始化才能使用其中的元素，如果只是賦值一個null則沒有進行new創(chuàng)建，那么將會發(fā)生空指針異常（NULLPOINTEREXCEPTION）,原因是忘了new，補上new則可解決。int []arrayA = null; arrayA = new int[3]; 數(shù)組的長度在程序運行期間不可改變。數(shù)組可以作為方法的參數(shù)和方法返回值實現(xiàn)傳輸或返回地址。如果希望方法中產(chǎn)生多個結(jié)果數(shù)據(jù)進行返回時可以使用一個數(shù)組作為返回值類型。
JAVA的內(nèi)存需要分五個部分：（紅色部分為重點） 1.棧（STACK）:需要存放方法中局部變量，方法的運行一定要在棧當中。局部變量是方法的參數(shù)，具有作用域（一旦超出作用域like從棧內(nèi)存消失） 2.堆（HEAP）：凡是new出來的東西都在堆當中，堆內(nèi)存里面的東西都有一個地址值（16進制），堆內(nèi)存里面的數(shù)據(jù)都有默認值（整數(shù)默認0，浮點默認0.0，字符默認\u0000,布爾默認false，引用默認null） 3.方法區(qū)（METHOD AREA）：存儲class相關(guān)信息，只是包含方法的信息，真正方法的運行在棧。 4.本地方法棧（NATIVE METHOD STACK）:與OS相關(guān)。 5.寄存器（PC REGISTER）:與CPU相關(guān)。
package come_two; public class demo03 { public static void main(String arg[]) { //數(shù)組動態(tài)初始化的數(shù)據(jù)格式,直接指定數(shù)據(jù)元素個數(shù) //數(shù)據(jù)類型[] 數(shù)組名稱 = new 數(shù)據(jù)類型[數(shù)組長度] //左側(cè)數(shù)據(jù)類型也就是保存的數(shù)據(jù)全部是統(tǒng)一的類型 //左側(cè)的中括號代表是一個數(shù)組，數(shù)組名稱表示一個名字 //右側(cè)的new表示創(chuàng)建數(shù)組的動作，數(shù)據(jù)類型必須和左邊數(shù)據(jù)類型一致 //數(shù)組長度表示數(shù)組中可以保存多少個數(shù)據(jù)，是一個int數(shù)字 int [] arrayA = new int[300];//創(chuàng)建數(shù)組 double [] arrayB = new double[10]; String[] arrayC = new String[100]; int [] arrayAA; arrayAA = new int[] {100,200,300}; //靜態(tài)初始化基本格式：數(shù)據(jù)類型[] 數(shù)據(jù)名稱 = new 數(shù)據(jù)類型[]{元素1，元素2，...} int [] arrayD = new int[] {5,15,25}; String [] arrayE = new String[] {"Hello","World"}; //省略格式：數(shù)據(jù)類型[] 數(shù)組名稱={元素1，元素2，...}； int []arrayZ = {10,20,30}; } }
package come_two; public class demo04 { public static void main(String args[]) { int [] array1 = {10,20,30}; System.out.println(array1);//[I@6a5fc7f7 內(nèi)存地址 //訪問數(shù)組元素的格式：數(shù)組名稱[索引值] //索引值從0開始，一直到數(shù)組長度-1為止，代表數(shù)組當中元素的編號。 System.out.println(array1[0]); System.out.println(array1[1]); //動態(tài)初始化與賦值 int [] array2 = new int[3]; System.out.println(array2); System.out.println(array2[0]); System.out.println(array2[1]); array2[0] = 100;//100賦值給0號元素 System.out.println(array2[0]); } } package come_two; //java內(nèi)存部分分析 public class demo05 { public static void main(String args[]) { int []array = new int[3];//動態(tài)初始化 System.out.println(array);//地址值 System.out.println(array[0]);//0 System.out.println(array[1]);//0 System.out.println(array[2]);//0 array[0] = 100; array[1] = 200; array[2] = 300; System.out.println(array);//地址值不變 System.out.println(array[0]);//100 System.out.println(array[1]);//200 System.out.println(array[2]);//300 /* 棧： main(String args[])信息在棧中運行，開辟一段棧中新內(nèi)存空間 局部變量 int []array 數(shù)組名稱即變量在棧中，根據(jù)地址可以找到堆中數(shù)組 System.out.println(array); 保存地址 array[0] 找到地址0x???? 重新賦值時修改堆內(nèi)數(shù)組空間元素值 堆： new int[3]在堆中開辟三個空間默認值為0，空間起始有地址0x????， 方法區(qū)： main方法頭放在方法區(qū) public static void main(String args[]) */ } }
package come_two; /* 1.如何獲取數(shù)組的長度與格式：數(shù)組名稱.length 2.遍歷數(shù)組：將數(shù)組中每一個元素逐一打印輸出. 3.求最大值 4.數(shù)組元素反轉(zhuǎn)：不能夠使用新數(shù)組，使用原數(shù)組 */ public class demo06 { public static void main(String args[]) { int [] array = {10,20,30,40,50,60,70,80,90,100}; int len = array.length; System.out.println("數(shù)組array的長度是："+len); //遍歷輸出，for循環(huán)或者原始順序輸出 for(int i = 0; i < array.length;i++) { System.out.println(array[i]); } printArray(array);//調(diào)用數(shù)組方法 //最值判斷 int max = array[0]; for(int i = 1; i < array.length; i++) { if(array[i] > max) { max = array[i]; } } System.out.println("最大值："+max); //數(shù)組元素反轉(zhuǎn):是對稱位置的元素交換 //對稱位置需要兩個索引：min，max //min==max或min》max時停止交換 即 min《max時應(yīng)該交換 int []arrayA = new int[] {10,15,6,100,89}; for(int i = 0; i < arrayA.length;i++) { System.out.println(arrayA[i]); } for(int min_1 = 0,max_1 = arrayA.length - 1; min_1 < max_1; min_1++,max_1--) { if(min_1 < max_1) { int temp = arrayA[min_1]; arrayA[min_1] = arrayA[max_1]; arrayA[max_1] = temp; } } for(int i = 0; i < arrayA.length;i++) { System.out.println(arrayA[i]); } System.out.println("============="); //老數(shù)組，長度永遠是3不能改變 int [] array1 = new int[3];//創(chuàng)建一個三個格子的變量空間 System.out.println("數(shù)組array1的長度是："+array1.length); //新數(shù)組，這里數(shù)組指的是堆中內(nèi)容 array1 = new int[5];//又創(chuàng)建新的5個格子的變量空間 System.out.println("數(shù)組array1的長度是："+array1.length); } public static void printArray(int array[]) { for(int i = 0; i < array.length;i++) { System.out.println(array[i]); } } } package come_two; //數(shù)組作為方法的返回值返回的其實也是地址值 //數(shù)組作為方法的參數(shù)傳遞進去的也是數(shù)組的地址值 public class demo07 { public static void main(String args[]) { int []result = caculate(10, 20, 30); System.out.println("main方法內(nèi)部數(shù)組是"); System.out.println(result);//地址值 System.out.println("總和為："+result[0]); System.out.println("平均值為："+result[1]); } public static int[] caculate(int a,int b,int c) { int sum = a + b + c; int avg = sum / 3; /* int []array = new int[2]; array[0] = sum; array[1] = avg; */ int array[] = {sum,avg}; System.out.println("caculate方法內(nèi)部數(shù)組是"); System.out.println(array);//地址值 return array; } }
7 面向?qū)ο?/span>7.1 過程和對象面向過程是當需要實現(xiàn)一個功能時每一個具體的步驟都要親力親為，詳細處理每一個細節(jié)，強調(diào)步驟。 面向?qū)ο笫钱斝枰獙崿F(xiàn)一個功能時不關(guān)心具體的步驟，而是找一個已經(jīng)具有該功能的人來做事，強調(diào)對象。面向?qū)ο蟮奶攸c是找一種復(fù)合思考習慣的思想，將復(fù)雜的事情簡單化并且將我們從執(zhí)行者變成指揮者。面向?qū)ο笾邪朔庋b、繼承和多態(tài)三大基本特征。 封裝是面向?qū)ο蟮暮诵?。將對象的屬性和行為封裝起來，將對象的屬性和行為封裝起來的載體是類，類通常對客戶隱藏實現(xiàn)細節(jié)。封裝是將一些細節(jié)信息隱藏起來，對于外界不可見。封裝在JAVA中的體現(xiàn)有（方法是封裝，關(guān)鍵字private是封裝）。 private（提高了代碼的安全性）修飾時本類中仍然可以訪問，但是超出本類之外不可直接訪問，但可以間接（具體步驟是get和set寫方法設(shè)置，set設(shè)置無返回值有參數(shù)，get設(shè)置有返回值無參數(shù)）。 繼承是類與類間存在關(guān)聯(lián)，A類與B類有關(guān)聯(lián)但不完全相同時，B類可以保留和繼承A類的共同特征，縮短軟件開發(fā)時間，復(fù)用已定義好的類。繼承主要體現(xiàn)為父類和子類間的聯(lián)系。 父類對象應(yīng)用于子類對象的特征是多態(tài)，多態(tài)的實現(xiàn)依賴于抽象類和接口。多態(tài)中父類通常定義為抽象類，在抽象類中給出一個方法的標準而不給出實現(xiàn)的具體流程。而在多態(tài)的機制中，比抽象類更為方便的方式是將抽象類定義為接口，由抽象方法組成的集合即為接口。 方法局部變量和類的成員變量重名的時候，根據(jù)就近原則優(yōu)先使用局部變量。如果需要訪問本類中的成員變量，需要使用格式this.成員變量。（通過誰調(diào)用的方法，誰就是this） package come_three; import java.util.Arrays; import java.util.Iterator; public class demo01 { public static void main(String args[]) { int []array = {10,20,30,40,50}; //面向過程，每個步驟親力親為 System.out.println("["); for(int i = 0; i < array.length; i++) { if(i == array.length - 1) { System.out.println(array[i] + "]"); }else { System.out.println(array[i]+","); } } //面向?qū)ο?找一個JDK提供好的array類 //其中tostring方法直接把數(shù)組編程想要的格式的字符串 System.out.println("==========="); System.out.println(Arrays.toString(array)); } } //文件1 package come_three; /* public class demo09 { String name; //參數(shù)who是對方的名字 //成員變量name是自己的名字 public void sayHello(String who) { System.out.println(who + "，你好。我是" + name); } } */ /* 方法局部變量和類的成員變量重名的時候，根據(jù)就近原則優(yōu)先使用局部變量。如果需要訪問本類中的成員變量，需要使用格式this.成員變量 通過誰調(diào)用的方法，誰就是this */ public class demo09 { String name; //參數(shù)who是對方的名字 //成員變量name是自己的名字 public void sayHello(String name) { System.out.println(name + "，你好。我是" + this.name); } } package come_three; public class demo10 { public static void main(String args[]) { demo09 persons = new demo09(); persons.name = "王健林"; persons.sayHello("王思聰"); } }
7.2 類和對象類是一種相關(guān)屬性和行為的集合，是一類事物的模板，使用事物的屬性特征和行為特征來描述該類事物。屬性是事物的狀態(tài)信息，行為是事物能夠做什么。對象是一類事物的具體體現(xiàn)，對象是類的一個實例，必然具備該類事物的屬性和行為。 比如：手上有個手機，手機的長寬高的特征是屬性，手機可以打電話發(fā)短信的能力是行為。 關(guān)系：類是對一類事物的描述，抽象的。對象是一類事物的具體實例，是具體的。類是對象的模板，對象是類的實體。 注意事項：成員方法直接定義在類當中，在方法外邊；成員方法不要寫static關(guān)鍵字。
通常一個類并不能直接使用，需要根據(jù)類創(chuàng)建一個對象才能使用。 需要以下步驟： 1.導(dǎo)包：也就是指出需要使用的類在什么位置。 import 包名稱.類名稱 對于和當前類屬于同一個包的情況，可以省略包語句不寫。 2.創(chuàng)建，格式： 類名稱 對象名 = new 類名稱（）； 3.使用，分為兩種情況： 使用成員變量，對象名.成員變量名 使用成員方法，對象名.成員方法名（參數(shù)） 成員變量沒有進行賦值時會有默認值，規(guī)則和數(shù)組相同。
成員變量和局部變量的區(qū)別：+ 方法的參數(shù)就是局部變量，參數(shù)在方法調(diào)用時必然被賦值。 1.定義位置不同：局部變量定義在方法內(nèi)部；成員變量定義在方法外部，直接寫在類中。 2.作用范圍不一樣：局部變量只有在方法中使用，出了方法不可以使用；整個類全部可以使用。 3.默認值不一樣：局部變量沒有默認值，如果要想使用必須手動賦值；成員變量不賦值會有默認值，規(guī)則和數(shù)組一樣。 4.內(nèi)存位置不一樣：局部變量位于棧內(nèi)存，成員變量位于堆內(nèi)存 5.生命周期不一樣：局部變量隨著方法進棧產(chǎn)生，隨著方法出棧消失；成員變量隨著對象創(chuàng)建而產(chǎn)生，隨著對象被垃圾回收而消失。 package come_three; /* public class Classname{ //成員變量 //成員方法 } */ /* 定義一個類，用于模擬學生事務(wù)，其中有兩個組成部分 屬性（是什么） 姓名 年齡 行為（能做什么） 吃飯 睡覺 學習 對應(yīng)到JAVA類中： 成員變量（屬性） String name; int age; 成員方法（行為） public void eat(); public void sleep(); public void study(); */ public class demo02 { //成員變量 String name;//姓名 int age;//年齡 //成員方法 public void eat() { System.out.println("吃飯"); } public void sleep() { System.out.println("睡覺"); } public void study() { System.out.println("學習"); } } package come_three; public class demo03 { public static void main(String args[]) { //導(dǎo)包 //使用的類在同一個包下可以省略導(dǎo)包語句 //創(chuàng)建 demo02 stu = new demo02(); //使用其中成員變量 System.out.println(stu.age); System.out.println(stu.name); stu.age = 36; stu.name = "趙麗穎"; System.out.println(stu.age); System.out.println(stu.name); stu.eat(); } } package come_three; public class demo04 { public static void main(String args[]) { //根據(jù)Phone類創(chuàng)建一個phone的對象 Phone phone = new Phone(); System.out.println(phone.brand); System.out.println(phone.color); System.out.println(phone.price); phone.brand = "iPhone SE"; phone.price = 8888; phone.color = "Blue"; System.out.println(phone.brand); System.out.println(phone.color); System.out.println(phone.price); phone.call("喬布斯"); phone.sendMessage(); //引用 Phone phone1 = phone; System.out.println(phone1.brand); System.out.println(phone1.color); System.out.println(phone1.price); phone1.brand = "iPhone SE"; phone1.price = 8888; phone1.color = "Blue"; System.out.println(phone1.brand); System.out.println(phone1.color); System.out.println(phone1.price); phone.call("喬布斯"); phone.sendMessage(); } } package come_three; public class demo05 { public static void main(String args[]) { //使用對象類型作為方法的參數(shù) //Phone one = new Phone(); //one.brand = "華為"; //one.color = "Blue"; //one.price = 8338; //method(one);//傳遞進去的參數(shù)是地址值 //使用對象類型作為方法的返回值 Phone two = gethPhone(); System.out.println(two.brand); System.out.println(two.color); System.out.println(two.price); } //使用對象類型作為方法的參數(shù) public static void method(Phone param) { System.out.println(param.brand); System.out.println(param.color); System.out.println(param.price); } //使用對象類型作為方法的返回值 public static Phone gethPhone() { Phone one = new Phone(); one.brand = "蘋果"; one.price = 8338; one.color = "BLUE"; return one; } }
package come_three; /* boolean類型當中的boolean值 get方法一定要寫成isXXX的形式 */ public class Student { private String name; private int age; private boolean male; public void setMale(boolean b) { male = b; } public boolean isMale() { return male; } public void setName(String str) { name = str; } public String getName() { return name; } public void setAge(int num) { age = num; } public int getAge() { return age; } } package come_three; public class demo08 { public static void main(String args[]) { Student stu = new Student(); stu.setName("蘆薈"); stu.setAge(20); stu.setMale(true); System.out.println("姓名："+stu.getName()); System.out.println("年齡："+stu.getAge()); System.out.println("是不是爺們兒："+stu.isMale()); } }
7.3 構(gòu)造方法加入構(gòu)造方法后，類可以由四部分組成：成員變量，無參構(gòu)造，有參構(gòu)造，setter和getter。 1. 構(gòu)造方法的名稱和所在的類名稱完全一樣，大小也一樣。 2. 構(gòu)造方法不需要返回值類型，void都不寫。 3. 構(gòu)造方法的調(diào)用是通過new關(guān)鍵字加上構(gòu)造方法名稱，而不是通過“.” 4. 構(gòu)造方法不能return一個具體的返回值。 5. 如果沒有編寫任何構(gòu)造方法，編譯期將會默認贈送一個構(gòu)造方法，沒有參數(shù)，方法體什么事情都不做。 6.一旦編寫至少一個構(gòu)造方法，那么編譯器將不再贈送。 7.構(gòu)造方法重載：方法名稱相同，參數(shù)列表不同
package come_three; /* 構(gòu)造方法是專門用來創(chuàng)建對象的方法，當通過關(guān)鍵字new來創(chuàng)建對象時其實就是在調(diào)用構(gòu)造方法。 格式： public 類名稱（參數(shù)類型 參數(shù)名稱）{ 方法體 } */ public class demo11 { //成員變量 private int age; private String name; //無參構(gòu)造 public demo11() { System.out.println("無參構(gòu)造方法執(zhí)行了!"); } //重載：有參構(gòu)造 public demo11(String name,int age) { System.out.println("有參構(gòu)造方法執(zhí)行了!!"); this.name = name; this.age = age; } //GETTER SETTER public void setName(String name) { this.name = name; } public void setAge(int age) { this.age = age; } public int getAge() { return age; } public String getName() { return name; } } package come_three; public class demo12 { public static void main(String args[]) { demo11 demo1 = new demo11(); //無參 demo11 demo2 = new demo11("趙麗穎",20); //全參 System.out.println("姓名：" + demo2.getName() + ",年齡：" + demo2.getAge()); //改變對象中成員變量數(shù)據(jù)內(nèi)容仍然需要使用setter方法 demo2.setAge(22); System.out.println("姓名：" + demo2.getName() + ",年齡：" + demo2.getAge()); } } package come_four; /* 一個標準的類通常滿足下面四個組成部分 1.所有的成員變量都要使用private關(guān)鍵字修飾 2.為每一個成員變量編寫一對getter/setter 3.編寫一個無參構(gòu)造方法 4.編寫一個有參構(gòu)造方法 標準的類成為 JAVA BEAN */ public class Student { private String name; private int age; //無參構(gòu)造 public Student() { } //有參構(gòu)造 public Student(String name,int age) { this.name = name; this.age = age; } //GETTER SETTER public void setName(String name) { this.name = name; } public void setAge(int age) { this.age = age; } public int getAge() { return age; } public String getName() { return name; } } package come_four; public class demo01 { public static void main(String args[]) { Student stu1 = new Student(); stu1.setName("迪麗熱巴"); stu1.setAge(22); System.out.println("姓名：" + stu1.getName() + ",年齡：" + stu1.getAge()); System.out.println("==========="); Student stu2 = new Student(); stu2.setName("古力娜扎"); stu2.setAge(32); System.out.println("姓名：" + stu2.getName() + ",年齡：" + stu2.getAge()); System.out.println("==========="); } }
7.4 API和ScannerAPI（Application Programming Interface）是應(yīng)用程序編程接口，是JDK提供給使用的類的說明文檔。 API使用步驟：打開幫助文檔；點擊顯示找到索引，回車；在輸入框輸入名稱后回車；看包（java.lang的類不需要導(dǎo)入包，其他需要）；看類的解釋和說明；學習構(gòu)造方法；使用成員方法。 Scanner是用戶能夠通過鍵盤輸入到程序中，使用步驟是導(dǎo)包、創(chuàng)建、調(diào)用。 package come_four; /* scanner是一個類，可以實現(xiàn)鍵盤輸入數(shù)據(jù)到程序中 引用類型的一般使用步驟： 1.導(dǎo)入包 import 包路徑.類名稱 如果需要使用的目標類和當前類位于同一個包可以省略導(dǎo)包語句 2.創(chuàng)建 類名稱 對象名 = new 類名稱（）； 3.使用 對象名.成員方法名（）； */ import java.util.Scanner; //導(dǎo)包 public class demo02 { public static void main(String args[]) { //創(chuàng)建 //System.in表示從鍵盤進行輸入 Scanner sc = new Scanner(System.in); //第一個案例：兩個數(shù)字相加 //System.out.println("請輸入第一個數(shù)字"); //int num1 = sc.nextInt(); //System.out.println("請輸入第二個數(shù)字"); //int num2 = sc.nextInt(); //int result = num1 + num2; //System.out.println("輸入的數(shù)字和是：" + result); //第二個案例：三個數(shù)最大？ System.out.println("請輸入第1個數(shù)字"); int num1 = sc.nextInt(); System.out.println("請輸入第2個數(shù)字"); int num2 = sc.nextInt(); System.out.println("請輸入第3個數(shù)字"); int num3 = sc.nextInt(); int temp = num1 > num2 ? num1 : num2; int max = temp > num3 ? temp : num3; System.out.println("輸入的數(shù)字最大值是：" + max); //獲取鍵盤輸入的字符串 //String str = sc.next(); //System.out.println("輸入的String字符串是：" + str); } }
7.5 匿名對象匿名對象是只有右邊的對象，沒有左邊的名字和賦值運算符。格式：new 類名稱（）；匿名對象只能使用唯一的一次，下次再用不得不再創(chuàng)建一個新對象。如果確定有一個對象只需要使用唯一的一次，就可以用匿名對象。匿名對象也可以作為參數(shù)和返回值。 package come_four; import java.util.Scanner; /* 創(chuàng)建對象標準格式 類名稱 對象名 = new 類名稱（）； */ public class demo03 { public static void main(String args[]) { //匿名對象的創(chuàng)建 // new Person().name = "吳協(xié)康"; // new Person().showName(); // 我叫，null //普通使用方式 // Scanner sc = new Scanner(System.in); // int num = sc.nextInt(); //匿名對象方式:使用一次 // int nums = new Scanner(System.in).nextInt(); // System.out.println("輸入的是：" + nums); //使用一般寫法傳入?yún)?shù) // Scanner sc = new Scanner(System.in); // methodParam(sc); //使用匿名對象傳入?yún)?shù) // methodParam(new Scanner(System.in)); Scanner sc = methoReturn(); int num = sc.nextInt(); System.out.println("輸入的是：" + num); // Person one = new Person(); // one.name = "楊毅"; // one.showName(); } public static void methodParam(Scanner sc) { int num = sc.nextInt(); System.out.println("輸入的是：" + num); } public static Scanner methoReturn() { //Scanner sc = new Scanner(System.in); //return sc; return new Scanner(System.in); } }
7.6 RANDOMRANDOM類用于生成隨機數(shù)據(jù)，使用步驟是導(dǎo)包、創(chuàng)建、調(diào)用。 獲取一個隨機的int數(shù)字（范圍是int所有范圍，有正負兩種）：nextInt（） 獲取一個隨機的int數(shù)字（參數(shù)代表了范圍，左閉右開區(qū)間）：[0,3)表示的是0-2，也是用nextInt（） package come_four; import java.util.Random; import java.util.Scanner; public class demo04 { public static void main(String args[]){ Random r = new Random(); //產(chǎn)生隨機數(shù)的方法 //int num1 = r.nextInt(); //System.out.println("隨機數(shù)是：" + num1); //產(chǎn)生0-9的隨機數(shù) //for (int i = 0; i < 100; i++) { // int num2 = r.nextInt(10);//參數(shù)代表范圍，左閉右開 // System.out.println("隨機數(shù)是：" + num2); //} //根據(jù)int變量n的值 獲取隨機數(shù)字 范圍是1-n //Scanner n = new Scanner(System.in); //int num3 = n.nextInt(); //for (int i = 0; i < 100; i++) { // int num4 = r.nextInt(num3) + 1 ; // System.out.println("產(chǎn)生的隨機數(shù)是：" + num4); //} //猜數(shù)字游戲 /* 首先產(chǎn)生一個隨機數(shù)據(jù)并且一旦產(chǎn)生不再變化 需要鍵盤輸入，用到scanner 獲取鍵盤輸入的數(shù)字 得到兩個數(shù)字 判斷是否太大，如果太大提示太大，如果太小提示太小，猜中則結(jié)束 */ int num = r.nextInt(100) + 1; Scanner sc = new Scanner(System.in); while(true) { System.out.println("請輸入你要猜的數(shù)字"); int guessnum = sc.nextInt(); if(guessnum > num) { System.out.println("太大了，請重試"); }else if (guessnum < num){ System.out.println("太小了，請重試"); }else { System.out.println("恭喜你猜對了"); break; } } System.out.println("游戲結(jié)束"); } }
|
|
|
