文章目錄

• 變量與運算符
• • 關鍵字和保留字
  • 標識符
  • 變量
  • • 數據類型
    • 自動類型提升
    • 強制類型轉換
    • 編碼的一些特殊情況
    • 字符串類型: String
    • 進制與進制間的轉換
    • 每日一考
  • 運算符
  • • 賦值運算符
    • 比較運算符
    • 邏輯運算符
    • 位運算符
    • 三元運算符
    • 每日一考
  • 程序流程控制
  • • 分支語句1(if-else):
    • 分支語句2(switch-case結構)
    • 循環結構
    • for循環的結構:
    • 每日一考
    • while循環的使用
    • do-while循環
    • while(true)死循環的特殊用法
    • 嵌套循環
    • 特殊的關鍵字使用
    • 帶標簽的break和continue的使用
  • 案例整合
  • java項目的項目結構
  • 基本數據類型和引用數據類型的區別
  • 數組
  • • 一維數組的使用
    • 多維數組的使用
    • 每日一考
    • 數組的賦值
    • Arrays工具類的使用

這個學習過程，說實話很艱辛，工作之余抽時間，看視頻，整理筆記，還得應付日常的開發工作，真的挺累的，導致更新的速度比較慢，幸好跌跌撞撞的把這些寫完了。后續會繼續補充面向對象的學習筆記。

變量與運算符

關鍵字和保留字

關鍵字的定義和特點

• 定義: 被java語言賦予了特殊含義
• 特點: 關鍵字中所有字母都為小寫

標識符

標識符的使用:

標識符: 凡是自己可以起名字的地方都叫標識符比如：類名、變量名、方法名、接口名、包名

標識符的命名規則:26個英文字母0-9，_或$,數組不可以開頭，不能使用關鍵字保留字，嚴格區分大小寫，長度無限制，標識符不能帶空格

java中的命名規范:

• 包名: 多單詞組成所有字母都用小寫
• 類名接口名:多單詞組成時，所有單詞首字母大寫 - 變量名、方法名: 多單詞組成時，第一個單詞首字母小寫，第二個大寫
• 常量名: 所有字母都大寫

變量

變量的概念:

• 內存中的一個存儲區域
• 該區域的數據可以再同一類型范圍內不斷變化
• 變量是程序中最基本的存儲單元。包含變量類型、變量名和存儲的值

變量的作用:

• 用于在內存中保存數據

使用變量注意:

• java中每個變量必須先聲明，后使用
• 使用變量名來訪問這塊區域的數據
• 變量的作用域: 其定義所在的一對{}內
• 變量只有在其作用域內才有效
• 同一個作用域內，不能定義重名的變量

/* 變量的使用 1. java定義變量的格式: 數據類型 變量名 = 變量值;2. 變量必須先聲明后使用3. 變量都定義在其作用域內。在作用域內他是有效的。換句話說，出了 作用域，就失效了4. 同一個作用域內，不能重名定義 */ class VariableTest {public static void main(String[] args){// 變量的定義int myAage = 12;// 變量的使用System.out.println(myAge);// 變量的聲明int myNumber;// 變量的賦值myNumber = 1001;// 變量的使用System.out.println(myAge);} }

數據類型

基本數據類型(primitive type)：整數類型(byte,short,int,long)、浮點類型(float、double)、字符型(char)、布爾(boolean)

引用數據類型: 類(class)、接口(interface)、數組([])

需要注意的是: 字符串(String)是一個類他是一個引用類型

/* Java定義的數據類型 個人補充一下字節的概念，比如我們有一段可以用來存儲的空間，里面單獨 拿出來一個格子我們默認這個格子只能存放0和1 1一個字節我們規定的是 8個bit其實代表的是就是這樣8個格子，那如果我們這個格子只放0和1能有 多少種組合范圍呢? 答案是2的8次方，也就是256，可是這樣如果我們只用 來表示0-256負數怎么辦，所以我們把其中一半 也就是2的7次方的數用來表 示負數，另外一半2的7次方用來表示正數，但是中間還有一個零，所以1字節 的表數范圍就是-2^7~2^7-1 一、變量按照數據類型來分:基本數據類型:整型: byte(1字節)\short(2字節)\int(4字節)\long(8字節)浮點型: float\double字符型: char布爾型: boolean引用數據類型:類(class)接口(interface)數組(array) */ class CariableTest1 {public static void main(String[] args){// byte(1字節=8bit)// byte范圍: -128~127byte b1 = 12;byte b2 = -128;// b2 = 128; 編譯不通過System.out.println(b1);System.out.println(b2);// 聲明long型變量，必須以'l'或者'L'結尾short s1 = 128;int i1 = 1234;long l1 = 34134134L;System.out.println(l1);// float(4字節)\double(8字節)// 定義float類型變量時，變量要以f或者F結尾float f1 = 12.3F;double d1 = 123.3;System.out.println(d1+1);System.out.println(f1);// 字符類型: char(1字符=2字節)// 定義char型變量，通常使用一對''// 只能寫一個字符char c1 = 'a';c1 = 'A';System.out.println(c1);// 布爾類型: boolean 只能取兩個值之一: true false// 常常在條件判斷、循環結構中使用boolean bb1 = true;boolean isMarried = true;if(isMarried){System.out.println("你結婚了");}else{System.out.println("單身狗");}} }

自動類型提升

注意類型轉換的時候是講8種基本數據類型中的布爾型給剔除掉了

/* 基本數據類型之間的運算規則:前提: 這里套路的只是7中基本數據類型變量間的運算，不包含Boolean類型*/ class VariableTest2{public static void main(String[] args){byte b1 =2;int i2 = 12;// 編譯不通過。會報錯，不兼容的類型，從int轉換到byte可能會有損失//byte b2 = b1 + i1;long l1 = b1 + i1int i2 = b1 + i1;float f = b1 + i1;System.out.println(l2);System.out.println(i2);System.out.println(f);// ********************char c1 = 'a'; //97int i3 = 10;int i4 = c1 + i3;System.out.prinln(i4);short s2 = 10;//char c2 = c1 + s2;// 編譯不通過 提示從int轉換到char可能會有損失// 其實到這里我們就可以猜測，char + short 得到的結果是int 而char c2 = 的這個動作就在做把int轉換的動作byte b2 = 10;// char c3 = c1 + b2; // 同樣的報錯，從int轉換到char可能會有損失// 所以可以知道 char + byte的結果是int//short s3 = b2 + s2; // 報錯 從int轉換到short可能會有損失// 所以 byte + short 結果是int} }

以上代碼得出結論:當容量小的數據類型的變量與容量大的數據類型的變量做運算時，結果自動提升為容量大的類型 （我這里說的容量指的是表示數字的范圍，不是說的字節數 注意嗷！）,特別的，byte、char、short三種類型的變量做運算時，結果為int類型
byte、char、short —> short —> int —> long —> float —> double
特別的: java在做運算的時候如果操作數均在int范圍內，那么一律在int的空間內運算

強制類型轉換

可以說是自動類型轉換的逆運算

/* 強制類型轉換: 自動類型提升運算的逆運算。 1. 需要使用強轉符： () 2. 注意點: 強制類型轉換，可能會導致精度損失 */ class VariableTest3 {public static void mian(String[] args){double d1 = 12.3;//int i1 = d1; 自然的會報錯，從double轉換到int可能會有損失//所以我們會采用以下這種方式去強制轉換類型int i1 = (int)d1;System.out.println(i1);// 得到結果12，注意計算d1是12.9那也是12// 這個強轉是一個截斷的操作// 沒有精度損失long l1 = 123;short s2 = (short)l1;int i2 = 123;byte b = (byte)i2;System.out.println(b);//結果是-128,這個要解釋就得用到二進制去解說了} }

編碼的一些特殊情況

class VariableTest4 {public static void main (String[] args) {// 1.編碼情況:注意我下面這個long型變量沒有以l或者L結尾，屬于是把一個int提升為了long自動類型提升了long l = 123213;// long l1 = 222222222222222;可以看到這個數沒有超過long的區間，但是會報錯過大的整數，因為你沒寫l默認先是int// 后做類型提升，顯然這個數對于int來講 太大了。System.out.println(l)// *******float f1 = 12.3;// 注意12.3如果不帶這個f 它默認是double型} } class VariableTest5 {public static void main(String[] args){byte b = 12;byte b1 = b + 1;// 報錯: int不能轉換成byte// 因為這里相當于是byte+int 由上文的自動類型提升可知結果// 根據上面f1的案例 可知:// 整型常量，默認類型為int型// 浮點型常量，默認類型為double型} }

字符串類型: String

• String 不是基本數據類型，屬于引用數據類型
• 使用方式與基本數據類型一致。例如: String str = “abc”;
• 一個字符串可以串接另外一個字符串，也可以直接串接其他類型數據。
• String 可以和八種數據類型做運算，且運算只能是連接運算:+ 運算的結果也是String

str = str + "xyz"; int n = 100; str str + n; - String 不是基本數據類型，屬于引用數據類型 - 使用方式與基本數據類型一致。例如: String str = "abc"; - 一個字符串可以串接另外一個字符串，也可以直接串接其他類型數據。 - String 可以和八種數據類型做運算，且運算只能是連接運算:+ 運算的結果也是String char c = 'a';//97 A:86 int num = 10; String str = "hello"; System.out.println(c + num + str);//107hello System.out.println(c + str + num);//ahello10 System.out.println(c + (num + str));//a10hello System.out.println((c + num) + str);//107hello System.out.println(str + num + c);// hello10aSystem.out.println("* *");// * * System.out.println('*' + '\t' + '*');//93 System.out.println('*' + "\t" + '*');//* * System.out.println('*' + '\t' + "*");//51* System.out.println('*' + ('\t' + "*"));//* *

進制與進制間的轉換

• 所有數字在計算機底層都以二進制形式存在

• 對于整數, 有四種表示方式:

  二進制:0,1 滿2 進1以0b或0B開頭

  十進制: 0-9,滿10進1

  八進制: 0-7 滿8進1以數字0開頭

  十六進制: 0-9及A-F,滿16進1，以0x或者0X開頭表示。此處A-F不區分大小寫

  如: 0x21AF + 1 = 0x21B0

class BinaryTest {public static void main(String[] args){int num1 = 0b110;int num2 = 110;int num3 = 0127;int num4 = 0x110A;// 輸出會以10進制輸出System.out.println("num1 = " + num1);System.out.println("num2 = " + num2);System.out.println("num3 = " + num3);System.out.println("num4 = " + num4);}}

• java 整數常量默認是int類型，當用二進制定義整數時，其中第32位是符號位，

  當是long 類型時，二進制默認占64位，第64是符號位

• 二進制的整數有如下三種形式:

  • 原碼: 直接將一個數值換成二進制，最高位是符號位
  • 負數的反碼: 對原碼取反，最高位確定為1
  • 負數的補碼: 其反碼加1

• 計算機以二進制補碼的形式保存所有整數

  • 正數的原碼、反碼、補碼都相同
  • 負數的補碼是反碼+1

toBinaryString(int i) ---> 2進制 toHexString(int i) ---> 16進制 toOctalString(int i) ---> 8進制

每日一考

標識符的命名規則有哪些

標識符的命名規范有哪些

包名: xxxyyyzzz

類名、接口名: XxxYyyZzz

變量名、方法名: xxxYyyZzz

常量名: XXX_YYY_ZZZ

java變量按照數據類型怎么劃分?并指出java的數據類型有哪幾種，并指出各自占用空間的大小

基本數據類型:

byte short int long

char

float double

boolean

引用數據類型: 類、接口、數組

說明基本數據類型變量之間自動類型提升的運算規則

byte、short、char —> int —> long —> float —> double

說明基本數據類型變量之間強制類型轉換的使用規則和強制可能出現的問題

容量大-》容量小 (上面的東西反過來)

需要使用強制轉換符

精度損失

運算符

算術運算符

class AriTest {public static void main(String[] args){// 除號: /int num1 = 12;int num2 = 5;int result1 = num1 / num2;System.out.println(result1);//2int result2 = num1 / num2 * num2;System.out.println(result2);// 10double result3 = num1 / num2;System.out.println(result3);// 2.0double result4 = num1 / (num2 + 0.0);System.out.println(result5);// 取余運算int m4 = 12;int n4 = 5;System.out.println("m4 % n4 = " + m4%n4);// (前) + +// (后) + +int a1 = 10;int b1 = ++a1;System.out.println("a1 = " + a1 + "b1 = " + b1);//a1 = 11,b1=11int a2 = 10;int b2 = a2++;System.out.println("a2 = " + a2 + "b2 = " + b2);//a2 = 11,b2 = 10// 注意點:short s1 = 10;//s1 = s1 + 1;// 編譯失敗s1 = (short)(s1 + 1);//正確s1++;//自增1不會改變本身變量的數據類型System.out.println(s1);//問題:byte bb1 = 127;bb1++;System.out.println("bb1 = " + bb1);//-128} }

ps： 說點真心話，自增自減這一塊的東西我自己是在js和c中都有接觸過的，所以沒有花太多時間在這個上面，如果是真的有人看我這個筆記學習的，請多花一點時間在這個運算符的練習題上。

/* 練習: 隨意給出一個整數，打印顯示個十百位數的值 */ class AriExer{public static void main(String[] args) {int num = 187;int bai = num / 100;int shi = num % 100 / 10;int ge = num % 10;System.out.println("個位數:" + ge);System.out.println("十位數:" + shi);System.out.println("百位數:" + bai );} }

賦值運算符

• 符號: =
  • 當 “=”兩側數據類型不一致時，可以使用自動類型轉換或者強制類型轉換進行處理
  • 支持連續賦值
• 擴展賦值運算符: +=,-=*=./=.%=

class SetVauleTest {public static void main(String[] args) {// 賦值符號: =int i1 = 10;int j1 = 10;int i2,j2;// 連續賦值i2 = j2 = 10;int i3 = 10,j3 = 20;//*************int num1 = 10;num1 += 2;// num1 = num1 +2System.out.println(num1);// 12// 同樣的 以上的擴展賦值運算符都是表示這個用法// 特殊的short s1 = 10;// s1 = s1 + 2;這個肯定編譯失敗，short型加int變成了整型，整型變量不做強轉直接賦值給shorts1 += 2;// 但是這個是可行的，還記得上文提到的 ++的用法嗎，同理。不會改變數據本身的數據類型System.out.println(s1);} }

練習題:

int i = 1; i *= 0.1 System.out.println(i);//0 i++ System.out.println(i);//1int m = 2; int n = 3; n *= m++; System.out.println("m=" + m);//3 System.out.println("n=" + n);//6int n = 10; n += (n++) + (++n);// n = n + (n++) + (++n) / n = 10 + 10 + 12 System.out.println(n);//32

比較運算符

相等于(==) 不等于(!=) 小于(<) 大于(>) 小于等于(<=)大于等于(>=) instanceof檢查是否是類對象

比較運算符結果都是boolean，也就是要么是true，要么是false 注意比較運算符的“==”別誤寫成賦值運算符的“=”

class CompareTest {public static void main(String[] args) {int i = 10;int j = 20;System.out.println( i == j);//falseSystem.out.println( i = j);//20// 其他的我就不寫了。} }

邏輯運算符

& — 邏輯與 | — 邏輯或 ! — 邏輯非 &&—短路與 || — 短路或 ^—邏輯異或

Untitled

class LogicTest {public static void mian(String[] args) {//區分 & 與 &&// 相同點1： & 與 &&的運算結果相同// 相同點2: 當符號左邊是true，二者都會執行符號右邊的運算// 不同點: 當符號左邊是false， & 會繼續執行符號右邊，&& 不在執行符號右邊boolean b1 = true;int num1 = 10;if(b1 & (num1++ > 0)) {System.out.println("我在上海");} else {System.out.println("我在北京");}boolean b2 = true;int num2 = 10;if (b2 && (num2 > 0)){System.out.println("我在北京");} else {System.out.prinln("我在上海");}// | 與 || 同理} }

位運算符

<< 左移 3< < 2 = 12 = ? 3 * 2 * 2 = 12 > > 右移 3>>1 = 1 =? 3/2 = 1> > > 無符號右移 3 >>> 1 =? 3/2 = 1& 與 6&3 = 2| 或運算 6|3 = 7^ 異或運算 6^ 3 = 5~ 取反 ~6 = -7

位運算是直接對整數的二進制的運算

三元運算符

• 格式:
  • 條件表達式 ？ 表達式1 : 表達式2
  • 表達式1與表達式2為同類型
  • 三元可以簡化if- else語句
  • 三元運算符必須返回一個結果

這個沒啥好講的

每日一考

“&&” 和 “&”的異同:

相同點1： & 與 &&的運算結果相同
相同點2: 當符號左邊是true，二者都會執行符號右邊的運算

不同點: 當符號左邊是false， & 會繼續執行符號右邊，&& 不在執行符號右邊

程序輸出

class OperatorTest {public static void main(String[] args) {boolean x = true;boolean y = false;short z = 40;// z == 40 ==>true==> z = 40 + 1// y = true// 執行循環if((z++ == 40) && (y = true)) {// z = 41 + 1z++;}// x = false// z = 42 + 1// z = 43if((x = false) || (++z == 43)) {// z = 43 + 1z++;}System.out.println("z = " + z);// z = 44} }

結果為:

定義3個int型變量并且賦值，使用三元運算符或者if-else獲取這三個數中較大數的實現:

int num1 = 10,num2 = 21,num3 = -21;int max; if (num1 >= num2 && num1 >= num3){max = num1; }else if(num2 >= num1 && num2 >= num3){max = num2; }else{max = num3; }

編寫程序，聲明2個double型變量并且賦值。判斷第一個數大于10.0，且第二個數小于20.0，打印兩數之和。否則，打印兩數的乘積

double d1 = 12.3; double d2 = 32.1;if (d1 > 10.0 && d2 < 20.0){System.out.println(d1 + d2); }else{System.out.println(d1 * d2); }

交換兩個變量值的代碼實現

String s1 = "北京";String s2 = "南京";String temp = s1;s1 = s2;s2 = temp;

程序流程控制

分支語句1(if-else):

if-else的三種格式：

/* // 1 if(條件表達式){執行代碼塊; } // 2 if(條件表達式){執行代碼塊1; } else{執行代碼塊2; } // 3 if(條件表達式1){執行代碼塊1; } else if(條件表達式2){執行代碼塊2; } ... else{執行代碼塊n; } */class IfTest {public static void main(String[] args) {//舉例1int heartBeats = 79;if (heartBeats < 60 || heartBeats > 100){System.out.println("你指定有點什么毛病");}System.out.println("檢查結束");// 舉例2int age = 23;if(age < 18){System.out.println("你只能看動畫片");} else {System.out.println("你可以看看成人電影了");}// 舉例3if(age < 0){System.out.println("非法輸入");}else if(age < 18){System.out.println("青少年時期");}else if(age < 35){System.out.println("青壯年時期");}else if(age < 60){System.out.println("中年時期");}else if(age < 120){System.out.println("老年時期");}else{System.out.println("老仙兒~")}} }

if 語句例題

張黎婕參加python考試，和他父親張熊達成承諾:

如果:

成績為100分，獎勵一輛BMW;

成績為(80-90],獎勵一臺iphone xs max;

當成績為[60-80]時，獎勵一個ipad

其他時，什么獎勵都無，

請從鍵盤輸入張黎婕的期末成績，并加以判斷

下面有個問題，如何從鍵盤獲取不同類型的變量

/*需要使用Scanner具體實現步驟1. 導包: import java.util.Scanner;2.Scaner的實例化(先會用，后面面向對象的時候再細說)3.調用Scanner類的相關方法，來獲取指定類型的變量String --- next()其他的 基本都是nextxxx() */ import java.util.Scanner;class ScannerTest{public static void mian(String[] args){Scanner scan = new Scanner(System.in);int num = scan.nextInt();System.out.println(num);System.out.println("請輸入你的名字:");String name = scan.next();System.out.println(name);System.out.println("請輸入你的年齡:");int age = scan.nextInt();System.out.println(age);System.out.println("請輸入你的體重");double weight = scan.nextDouble();System.out.println(weight);System.out.println("你是男的還是女的?(true(男)/false(女))")boolen isLove = scan.nextBoolean();// 對于char類型的獲取，Scanner沒有提供相關的方法，只能獲取一個字符串// 但是String提供了charAt()的方法供String提取成字符// String s = "張熊"; char c = s.charAt(0); System.out.println(c)==> 張} }

需要注意的時Scanner在調用相應方法來獲取屏幕上的值的時候，需要輸入的類型與你調用的方法類型一致。如果輸入數據類型與要求類型不匹配時，會報異常: InputMisMatchException導致程序終止。

回到張黎婕的題目：

import java.util.Scanner; class IfTest {public static void main(String[] args) {Scanner scan = new Scanner(System.in);System.out.println("請輸入張黎婕期末成績: (0-100)");int score = scan.nextInt();if (score == 100){System.out.println("獎勵一輛BMW");}else if(score > 80 && score <=99){System.out.println("獎勵一臺iphone xs max");}else if(score >= 60 && score <= 80){System.out.println("獎勵一個ipad");}else{System.out.println("什么獎勵也沒有");}} }

留幾個題目，自己去寫吧:

編寫程序: 由鍵盤輸入三個整數分別存入變量num1、num2、num3，對他們進行排序(使用if-else if-else),并且從小到大輸出。

輸出題:

class IfExer {public static void main(String[] args) {int x = 4;int y = 1;if (x > 2)if (y > 2)System.out.println(x + y);elseSystem.out.println("x is" + x);} }

考慮一下else的就近原則

輸出題:

boolean b = true; // 如果寫成if(b=false)能編譯通過嗎? 如果能，結果是? if (b == false)System.out.println("a"); else if(b)System.out.println("b"); else if(!b)System.out.println("c"); elseSystem.out.println("d");

編寫程序，聲明2個int變量賦值。判斷兩數和，如果大于50，打印helloworld

如果狗前兩年每年相當于人類的10.5歲，之后沒增加一年就等同于增加4歲，那么現在5歲的狗相當于人類多少年齡呢?(編寫程序，屏幕輸入狗子年紀，負數提示報錯）

彩票游戲，程序隨機產生一個兩位數的彩票，提示用戶輸入一個兩位數，按如下規則去判定用戶是否贏錢

用戶輸入數字對，順序對，獎勵10 000

數字對，順序不對，獎勵3 000

數字對一個，且順序對位，獎勵1 000

數字對一個，順序不對， 獎勵500

數字都不對，彩票作廢

提示: 使用(int)(Math.random()*90 + 10) 產生隨機數

/* 獲取隨機數 */ double value = Math.random() * 100; //獲取的是[0.0,1.0)區間內的數字

分支語句2(switch-case結構)

switch語句的基本使用格式:

switch(表達式){case 常量1:語句1;//break;case 常量2:語句2;//break;... ...case 常量N:語句Nl;//break;default:語句;//break; }

大概的執行順序是，如果根據表達式匹配到常量1.那就執行語句1，如果常量1-常量N都沒有匹配到，則其他情況都會被默認成default的情況，執行default下的語句。如果語句1執行完之后，寫了break則不再執行后續內容，直接結束整個switch語句，如果沒有寫break，則會沿著代碼順序一直運行至default下的語句。

總結如下:

① 根據switch表達式中的值，依次匹配各個case中的常量。一旦匹配成功，則進入相應case結構中，調用其執行語句。當調用完執行語句后，則任然繼續向下執行其他case結構中的執行語句，直到遇到break關鍵字或此switch-case結構末尾結束為止。

② break，可以使用在switch-case結構中，表示一旦執行到此關鍵字，就跳出switch-case結構。

③ switch結構中的表達式，只能是如下6種數據類型之一: byte、short、char、int、枚舉類型(JDK5.0新增)、String類型(JDK7.0新增)

④ case之后只能聲明常量，不能聲明范圍。

int age = 10; switch(age): // 錯誤 case age>18:System.out.prinln("成年了"); default:System.out.prinln("未成年");

⑤ break關鍵字是可選的

⑥ default: 相當于if-else結構中的else，位置靈活

int age = 10; switch(age): // 雖然可以這么寫，但是這可讀性太差了 別這么寫 別這么寫 別這么寫 default:System.out.prinln("未成年"); case 18:System.out.prinln("成年了");

例題:

使用switch把小寫的char轉換成大寫。只轉換a,b,c,d,e其他輸出other(整個題目的難點在怎么從屏幕獲取一個char，如果上文看了應該知道，scan方法沒有專門為char提供next方法，需要獲取字符串，然后通過字符串.charAt(N),來獲取字符串中第N位的字符)

int score = 78; switch(score / 10){case 0:case 1:case 2:case 3:case 4:case 5:System.out.println("不及格");break;case 6:case 7:case 8:case 9:case 10:System.out.println("不及格");break; } // 特意把這題寫一下說一下，可以這么寫，把多種情況合并一下 這并不是這道題的最優解

輸入學生成績，大于60輸出"合格", 低于"60"輸出“不合格”

根據用于指定月份，打印月份季節(345春，678夏，9，10，11 秋， 12 ，1 ，2 冬季)

編寫程序: 從鍵盤上輸入2020年的"month"和"day",要求通過程序輸出輸入的日期為2020年的第幾天

說明:

凡是可以使用switch-case的結構，都可以轉換為if-else。反之，不成立。

當我們寫分支結構時，當發現既可以使用switch-case，(同時，switch中表達式不多的取值情況不太多)又可以使用if-else時，我們優先選擇使用switch-case。原因: switch-case執行效率稍高

循環結構

在某些條件滿足的情況下，反復執行特定代碼的功能

循環語句分類:

for 循環

while 循環

do-while循環

循環語句的四個組成部分:

初始化部分

循環條件部分 — 》 boolean類型

循環體部分

迭代部分

for循環的結構:

for(①; ②; ④){③; } // 執行過程① --> ② --> ③ --> ④ --> ② --> ③ --> ④ ... --> ② --> ③ --> ④ /* 如果 要草這個人的媽十次 */ class ForTest {public static void main(String[] args) {// 沒學for循環前的我System.out.println("我草泥馬");System.out.println("我草泥馬");System.out.println("我草泥馬");System.out.println("我草泥馬");System.out.println("我草泥馬");System.out.println("我草泥馬");System.out.println("我草泥馬");System.out.println("我草泥馬");System.out.println("我草泥馬");System.out.println("我草泥馬");// 就很累// 學了for循環的我for(int i = 1; i <= 10; i++){System.out.println("我草泥馬");}// 輕松 而且優雅} }

反人類練習

int num = 1; // 注意println和print的差別，一個換行輸出，一個不換 for(System.out.print("a"); num <= 3; System.out.print('c'), num++){ // 注意上面那個逗號 ',' 是這么寫的 不會報錯。System.out.print('b'); } // 輸出結果: abcbcbc

接下來要說一個問題，for循環的i只在for循環內部有效，出了for循環就失效了。

遍歷100以內的偶數,且輸出偶數的和

// 遍歷100以內的偶數 for(int i = 1; i <= 100; i++){if (i % 2 == 0){System.out.println(i);} }//遍歷100以內的偶數,且輸出偶數的和 int sum = 0; for(int i = 1; i <= 100; i++){if (i % 2 == 0){System.out.println(i);sum += i;} } System.out.println("總和為:" + sum);// 思考題: 去記錄偶數的個數

每日一考

switch后面使用的表達式可以是哪些數據類型的

使用switch語句改寫下列if語句

int a = 3; int x = 100; if (a == 1)x += 5; else if(a == 2)x += 10; else if(a == 3)x += 16; elsex += 34;

談談你對三元運算符、if-else和switch-case結構使用場景的理解

如何從控制臺獲取String和int型的變量，并輸出? 使用代碼實現

使用for循環遍歷100以內的奇數，并計算所有奇數和并輸出。

while循環的使用

回顧一下循環的4個要素

① 初始條件

② 循環條件

③ 循環體

④ 迭代條件

那么while循環中，這四個要素是怎么起作用的呢

① while(②){③;④; }

知道了基本的用法，我們來看看實際例題

/*遍歷100以內的所有偶數 */ class WhileTest{public static void mian(String[] args) {// 遍歷100以內的所有偶數int i = 1;while(i <= 100){if(i % 2 == 0){System.out.println(i);}//迭代條件,不寫意味著死循環 ，i永遠小于一i++;}// 注意哦！ 這里的i和for循環的i不同，你是定義在循環體外部的所有出了循環之后，依舊是可以使用的System.out.println(i);// 101} }

好的！ 學會了以上的用法，基本上就懂了while循環的使用了，接下來說幾個需要注意的點:

寫while循環千萬小心不要丟了迭代條件。一旦丟了，就可能導致死循環！

避免出現死循環

for循環和while循環是可以相互替換的！

知道了以上幾點，有的人可能會疑慮，那么while循環的執行順序是怎么樣的呢:

① —> ② —> ③ —> ④ —> ② —> ③ —> ④…

do-while循環

①; do{③;④; }while(②);

執行順序：① —> ③ —> ④ —> ② —> ③ —> ④ —> ②;

意思就是不管你符不符合這個②的條件，程序在從上至下執行的過程中，會先走一次①③④再去判斷這個是否滿足②的條件。

while(true)死循環的特殊用法

/*從鍵盤讀入個數不確定的整數，并判斷讀入的正數和負數的個數，輸入為0時結束程序 */ import java.util.Scanner class ForWhileTest{public static void mian(String[] args) {Scanner scan = new Scanner(System.in);int positiveNumber = 0;// 記錄正數的個數int negativeNumber = 0;// 記錄負數的個數while(true){// for(;;){ 這種寫法也是等于死循環的int number = scan.nextInt();// 判斷number的正負情況if(number > 0){positiveNumber++;} else if (number < 0) {negativeNumber++;} else {// 一旦執行就跳出循環break;}}System.out.println("輸入的正數個數為: " + positiveNumber);System.out.println("輸入的正數個數為: " + negativeNumber);} }

嵌套循環

主要是有些同學，嵌套的層數多了就容易迷糊，所以專門拿出來說一下

嵌套循環: 將一個循環結構A聲明在另一個循環結構B的循環體中，就構成了嵌套循環

經典例題: 輸出九九乘法表

/* 九九乘法表 1 * 1 = 1 2 * 1 = 2 2 * 2 = 4 ... 9 * 1 = 9 ......... 9 * 9 = 81 */ class NineNineTable {public static void main (String[] args) {for (int i = 1; i <= 9; i++){for (int j = 1; j <= i; j++){// 注意這里不換行System.out.print(i + "*" + j + " = " + (i * j)+ " ");}// 換行System.out.println();}} }

思考題: 輸出100 以內所有質數(也叫素數，只能被一和它本身整除的自然數)

public PrimeNumberTest {public static void main(String[] args) {boolean isFlag = true;// 標識i是否被j除凈，一旦除凈 倒旗for(int i = 2; i <= 100; i++){for(int j = 2; j < i; j++){if(i % j == 0){ // i被j除盡isFlag = false; }}}} }

特殊的關鍵字使用

break與continue

這個沒啥好特殊說明的記住一句話，然后看代碼演示

break 跳出所有循環，continue跳出當前循環

class BreakContinueTest {public static void main(String[] args){for(int i = 1; i <= 10; i++){if(i % 4 == 0){break;// 會輸出123//continue;// 會輸出123567910// System.out.println("我是你ge");這里寫了就報錯，關鍵字后面不允許饑接這個。}System.out.println(i);}} }

帶標簽的break和continue的使用

class BreakContinueTest {public static void main(String[] args){label:for(int i = 1;i < 4; i++){for(int j = 1;j <= 10; j++){if(i % 4 == 0){continue;// 默認是跳出此關鍵字最近的一層循環continue label;// 結束指定的label標識的循環}}} } }

案例整合

以上知識點我們在這里通過一個案例來整合一下,案例需求如下:

模擬實現一個基于文本界面的<記賬軟件>

主要涉及以下知識點:

變量的定義

基本數據類型的使用

循環語句

分支語句

方法聲明、調用和返回值接收

簡單的屏幕輸出格式控制

大概的用戶展示界面如下

• • • • • • 家庭收支記賬軟件 - - - - - -

收支明細

登記收入

登記支出

退出

具體代碼附上git地址，關于git使用移步至

java項目的項目結構

一般不管用什么開發工具，我們習慣先建一個java工程(java project),此處我是使用的idea，大部分java入門的是采用eclipse,但是我懶得去下了，這本來就是平時開發工作中用的比較多的一個開發工具。以下是具體的使用步驟。

---

安裝好軟件之后，打開idea按如下步驟操作

選擇好你電腦上配置好的java環境的jdk，然后點擊next

按步驟點擊之后，在新的窗口或者原窗口展示

在src目錄下

基本數據類型和引用數據類型的區別

基本數據類型:

整型變量: long、int、short、byte

浮點型: float、double

字符類型: char

布爾類型: boolean

引用數據類型

所有非基本數據類型的數據都算是引用數據類型，大致包括(類、 接口類型、 數組類型、 枚舉類型、 注解類型、 字符串型)

當然，這些不能作為區分基本數據類型和引用數據類型的標準，其具體的區別在于在內存中的存放形式，聊這個之前先要了解堆和棧的概念

數組

這里說以下，因為我是從python轉到java來的，這個數組這個數據結構再python中也有類似的，但是python中稱為列表，如果同樣有這種基礎的同學，方便你的后續學習內容的理解

---

數組(Array),是多個相同類型數據按一定順序排列的集合，并使用一個名字命名，并通過編號的方式對這些數據統一管理。粗略的文字說明可能不太形象，大家不知道對數學中的"集合"的概念還有沒有印象，比如我現在有很多數字 1, 2, 3, 4,我可以說他是有理數集合中的元素，那在編程中，也有類似的‘集合’我們稱之為數組，當然他們是有很多區別的，后續我們慢慢說。java中，把這些數用一個符號標注起來使他成為這期我們要學的數組[1,2,3,4,5]?，F在我們思考一個問題這些數這些數為什么被劃分到有理數集合中，本質是因為1，2，3，4這些數都是有理數，所以同樣的，java中把這種有相同數據類型的變量，統一放入一個容器中，這個容器就叫做數組

數組的特點:

數組我們可以把它看成是一個只能裝某一個種數據類型的容器，數組本身是一個引用數據類型,區別于基本數據類型(byte,short,int,long,char,float,double,boolean)其內的元素可以是基本數據類型也可以是引用數據類型(String)

創建數組對象會在內存中開辟一整塊連續的空間，而數組名中引用的是這一塊連續空間的首地址

數組的長度一旦被確定，就不能修改

我們可以通過下標或索引的形式去獲取元素，速度很快。

一維數組的使用

一維數組的聲明和初始化

如何調用數組的指定位置的元素

如何獲取數組的長度

如何遍歷數組

數組元素的默認初始化值

數組的內存解析

public class ArrayTest {public static void main(String[] args){// 一維數組的聲明int num;// 聲明num = 10;// 初始化int num = 10;int[] ids;// 聲明變量// 1.1 靜態初始化:數組的初始化和數組元素的賦值操作同時進行ids = new int[]{1001,1002,1003,1004};// 1.2 動態初始化:數組的初始化和數組元素的賦值操作分開進行String[] names = new String[5];// 總結: 數組一旦初始化完成，其長度就確定了，為啥要確定呢，你不確定電腦怎么給你分配確定空間的內存呢// 如何調用指定位置的元素: 通過角標的方式name[0] = "小張";name[1] = "小周";name[2] = "小虎";name[3] = "小龍";name[4] = "小朱";// 語法上這里都是可以過的，但是運行的時候，正真把數據加載到內存中后，會報// ArrayIndexOutOfBoundsException//name[5] = "小王";// 如何獲取數組的長度// 屬性: lengthSystem.out.println(name.length);//5System.out.println(ids.length);// 如何遍歷數組for(int i = 0; i < names.length; i++){System.out.println(names[i]);}// 數組元素的默認初始化:整型int[] arr = new int[4];for(int i = 0; i < arr.length; i++){System.out.println(arr[i]);// 會輸出四個0}// 整型: 0short[] arr1 = new short[4];for(int i = 0; i < arr1.length; i++){System.out.println(arr1[i]);}//浮點型: 0.0//字符類型: assci碼的0 或者說是'\u0000' 輸出出來是一個空格的效果，注意不是空格，只是空格的效果//布爾類型: false// 除了基本數據類型，還有引用數據類型 nullString[] arr5 = new String[5];System.out.println(arr5[0]);// 內存解析:// 見上方的 基本數據類型和引用數據類型中提到的內容，這一塊對于新手來說，已經不是文字這么好解釋的了// 建議去看看具體的視頻，新手推薦尚硅谷的https://www.bilibili.com/video/BV1Kb411W75N?p=146，其中P145-P146// 其中還有一個知識點，對于String[] arr1 = new String[4] String 本身是在常量區中的，對于這種// 數組，堆中的list的內存空間只是持有常量區的引用。但是在JDK8以后，把常量池放到了堆里面，取消了方法區。} }

多維數組的使用

多維數組本身不叫多維數組，它形似[[“張熊”,“743146159”],[“熊”,“123498765”]]最外層的數組的每一項代表對內層數組的引用

對于二維數組的理解，我們可以看成是一維數組array1又作為另一個一維數組array2的元素而存在

二維數組的聲明和初始化

如何調用數組的指定位置的元素

如何獲取數組的長度

如何遍歷數組

數組元素的默認初始化值

數組的內存解析

public class ArrayTest2 {public static void main(String[] args) {// 靜態初始化int[][] arr1 = new int[][]{{1,2,3},{2,3,4},{4,5,6}};// 動態初始化String[][] arr2 = new String[3][2];// 這樣也行int[] arr3[] = new int[][]{{1,2,3},{1,2,3}};int[] arr5[] = {{11,1,2},{2,2,2},{3,4,4}}// 調用System.out.println(arr1[0][1]);// 獲取數組長度System.out.println(arr1.length);//3// 如何遍歷 for循環嵌套 偷懶不想寫了，大概理解一下吧//二維數組的使用int[][] arr = new int[4][3];System.out.println(arr[0]);// 輸出arr[0]對應的這個數組的地址值System.out.println(arr[0][0]);// 0 其他類型參照一維數組} }

每日一考

寫出一維數組初始化的兩種方式

寫出二維數組初始化的兩種方式

如何遍歷如下的二維數組

不同類型的一維數組元素默認初始化值各是多少

數組的賦值

如果有一個數組arry1 = new int[]{2,3,5,7,11,13,17,19}; 如果arry2 = arry1，此時如果對arry2進行修改，那arry1會不會有影響呢？因為在堆空間中，實際只有一個數組，但是arry1與arry2兩個變量在?？臻g中，此時的賦值操作，只是把這兩個變量都指向了同一個引用

Arrays工具類的使用

binarySearch(char[] a,char key)二分查找返回結果這個key首次出現的索引位置

equals(int[] a,int[] b)判斷兩個數組是否相等，返回布爾值

toString(int[] a)輸出數組信息，返回值是一個String

fill(int[] a,int val)將指定值填充到數組中

sort(int[] a)對數組排序

public class ArraysTest {public static void main(String[] args) {// 1.boolean equals(int[] a,int[] b)int[] arr1 = new int[]{1,2,3,4};int[] arr2 = new int[]{1,3,2,4};boolean isEquals = Arrays.equals(arr1,arr2);System.out.println(isEquals);// 原碼里面，校驗了四個方面，兩個數組地址值是否相等(a == a1)，兩個是否為null(a == null || a1 == null)，長度是否相等，以及最后內部元素是否相等//2.String toString(int[] a)System.out.println(Arrays.toString(arr1));//"[1,2,3,4]"//3.void fill(int[] a,int val)Arrays.fill(arr1,10);System.out.prinln(Arrays.toString(arr1));//[10,10,10,10],就是把原來的值全部替換//4.void sort(int[] a)Arrays.sort(arr2);// 底層用了一個快排的類System.out.println(Arrays.toString(arr2));//5. int binarySearch(int[] a,int key)// 就二分法查找 沒找到返回一個負數} }

幾個比較常見的異常: 越界(ArrayIndexOutOfBoundsExcetion)、空指針(NullPointerException)

總結

以上是生活随笔為你收集整理的重整旗鼓学java之java基础的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。