CGBTN2108復習匯總

復習思路:

先抓知識結構主干，再去補充細節
先跟著老師的復習思路走，遇到會的，快速回顧
遇到忘記或者是不會的，先記錄，后面自己復習的時候著重回顧

`一階段學習路徑：`

在這里插入圖片描述

1 基礎語法Basic

1.環境的配置

安裝JDK
注意:可以安裝多個JDK,我們使用的是1.8,環境變數配置哪個,哪個就生效
環境變數的配置
JAVA_HOME : 配置的是JDK安裝的目錄
Path : 配置的是JDK的bin目錄,不新建的
CLASS_PATH:配置的是JDK的lib目錄
win+R 打開 ,命令:java -version,出現版本號即為成功
開發工具eclipse
開發工具IDEA–設定字體大小/顏色
注意: 安裝的路徑不要出現中文

2.JDK JRE JVM

JDK:Java開發工具包–開發的最小單位
JRE:Java運行時環境–運行的最小單位
JVM:Java虛擬機–負責加載并運行對應的位元組碼檔案.class

運行程序: 我們撰寫的原始碼是.java為后綴的,通過編譯生成的是.class位元組碼檔案,交給JVM來執行
跨平臺: 只要在不同的作業系統上安裝對應的JVM,就可以實作跨平臺:一份代碼處處運行

3. 語法基礎

1.關鍵字 :

50個全小寫的單詞,在Java有特殊的意義,還包含2個保留字const goto

2.識別符號 :

字母數字下劃線美元符號組成,不能以數字開頭,區分大小寫,關鍵字+(true false null)也不可以用作識別符號,見名知意

類名: Upper駝峰命名:每一個單詞的首字母都要大寫
方法名: Lower駝峰命名: 除了第一個單詞以外,其他單詞的首字母都要大寫

3.注釋 :

單行注釋多行注釋檔案注釋(還可以添加一些額外的資訊:作者時間版本引數回傳值型別)
注釋可以注釋內容,被注釋的內容不執行,所以我們可以利用注釋的手段做代碼的測驗

4 變數:

成員變數:類里方法外,類消失,成員變數才會消失

成員有自己的默認值,可以不手動賦值

區域變數:方法里/代碼塊里,當區域代碼結束,區域變數也隨之釋放

區域變數使用的時候,必須賦值,可以:
宣告的時候并且賦值 Cat cat = new Cat();
先宣告再賦值 Cat cat; cat = new Cat();
注意:基本型別保存的是值,參考型別保存的是地址值

變數的就近原則:離誰近就使用誰

如果想指定本類的成員變數,使用this.變數名來指定
如果想指定父類的成員變數,使用super.變數名來指定

5 八大基本型別:

Java的資料型別分為兩類:基本型別 + 參考型別
在這里插入圖片描述

6.字面值規則:

整數型別的字面值型別是int
浮點型別的字面值型別是double
byte short char 三種比int小的型別,可以在范圍內直接賦值
三種字面值后綴 : L D F
三種字面值前綴: 0b-二進制 0-八進制 0x-十六進制

練習題:進制的前綴

package cn.tedu.basic;
/*本類用于測驗型別的前綴*/
public class TestTypePre {
    public static void main(String[] args) {
        //10-2 10-1  10-0
        System.out.println(100);//100-10的平方
        //操作二進制-0b
        //2-2 2-1 2-0
        System.out.println(0b100);//4-2的平方
        //操作八進制
        //8-2 8-1 8-0
        System.out.println(0100);//64-8的平方
        //操作十六進制
        //16-2 16-1 16-0
        System.out.println(0x100);//256-16的平方
    }
}

7.運算規則:

運算結果的資料型別與參與運算的最大型別保持一致 int+int->int double/int->double
整數運算會出現溢位的現象,一旦溢位,資料就不正確了(光年案例)
byte short char三種比int小的型別,運算的時候需要先自動提升int型別,再參與運算
浮點數的特殊值:Infinity NaN
浮點數運算不精確的問題

8.型別轉換

口訣:小轉大,直接轉大轉小,強制轉浮變整,小數沒

注意:布爾型別不參與型別轉換
注意:基本型別之間能否轉換,不取決于位元組數,位元組數只能做參考,取決于型別的取值范圍
注意:我們這里所說的是基本型別之間的轉換,參考型別之間的轉換取決于是否有繼承關系
比如:你可以說小貓是小動物,但是不能說小貓是小汽車,不然后面的這種錯誤的情況會報:型別轉換例外

練習題:型別之間的轉換與字面值規則

package cn.tedu.basic;
/*本類用來測驗型別轉換
* 1.byte1--short char2--int4--long8--float4--double8
* 2.小到大 直接轉:隱式轉換,可以直接轉換
*   大到小 強制轉:顯式轉換,需要強轉,注意發生資料溢位的問題
*   浮變整 小數沒:小數部分直接被舍棄
* 3.強制型別轉換的格式:目標型別 變數名 = (目標型別)要轉換型別的資料;
* */
public class TestTypeChage {
    public static void main(String[] args) {
        byte a = 10;
        short b = a;//不會報錯,小轉大

        int c = 1;
        long d = c;//不會報錯,小轉大

        float f = 3.1415f;
        double e = f;//不會報錯,小轉大

        long g = 8274624867L;
        float h = g;//不會報錯,小轉大
        System.out.println(h);

        char i = 'a';
        int j = i;//不會報錯,小轉大
        System.out.println(j);//97

        int a1 = 1;
        byte b1 = 2;
        //byte c1 = a1+b1;會報錯,大轉小
        byte c1 = (byte) (a1+b1);//需要強制型別轉換

        byte d1 = (byte) 128;
        System.out.println(d1);//-128,需要強轉,注意發生資料溢位的問題

        short e1 = 'a';
        char f1 = 120;
        System.out.println(e1);//97,列印的是編碼值
        System.out.println(f1);//'x',列印是根據編碼找到的字符

        float h1 = 32874.435F;
        int i1 = (int) h1;//大轉小 強制轉
        System.out.println(i1);//32874 浮變整 小數沒
    }
}

9.運算子

普通的四則運算子 + - * / ,普通的四則運算,并不能直接改變變數本身的值,除非 i = i*10+8
取余 % 6%4=2 6%3=0(余數為0表示整除)
自增自減運算子
1. 可以改變變數本身的值
  2)前綴式: 符號在前,先改變變數本身的值(+1/-1),再使用(列印/參與運算…)
  3)后綴式: 符號在后,先使用(列印/參與運算…),再改變變數本身的值(+1/-1)
  4)注意:不管是前綴式還是后綴式,一定是會改變變數本身的值,區別在于執行的時機不同
比較運算子
1. 比較運算子最終的結果是布爾型別的
2. < >= <=
3. == 比較的是左右兩邊的值是否相等 !=比較的是左右兩邊的值是否不相等

練習題:==比較的練習

    package cn.tedu.basic;

public class TestOperator {
    public static void main(String[] args) {
        //參考型別Cat型別的變數c1 c2 保存的是物件的地址值
        Cat c1 = new Cat();
        Cat c2 = new Cat();

        int[] a1 = {1, 2, 3};
        int[] a2 = {1, 2, 3};

        int b1 = 4;
        int b2 = 4;

        boolean f1 = true;
        boolean f2 = true;
        /* == 如果比較的是基本型別,比較的是值,字面值,具體存的那個數*/
        System.out.println(b1 == b2);//true
        System.out.println(f1 == f2);//true

        /* == 如果比較的是參考型別,比較的也是值,地址值*/
        System.out.println(c1 == c2);//false
        System.out.println(a1 == a2);//false
    }
}

class Cat {
    String name;
    int age;

    public void bark() {
        System.out.println("小貓喜歡喵喵叫");
    }
}

邏輯運算子
1. 雙與/短路與/&& :判斷邏輯與&一致,增加了短路的功能全真才真,有假則假
  2)雙或/短路或/|| :判斷邏輯與|一致,增加了短路的功能全假才假,有真則真
  注意:我們這里所說的短路,是指在某些情況下,運算式后半部分就不用計算了,因為我們已經知道了結果,也就是被短路了,短路可以提高程式的性能,但是短路不一定會用到
三目運算子: 1 ? 2 : 3; 1是運算式,1真取2,1假取3
復合賦值運算子:+= -= *= /=是一種簡寫的形式,比較方便,運算時會自動進行型別轉換
賦值運算子: = ,右邊給左邊
拼接功能:+
位運算子 : 主要參與的是二進制的運算
&與:全真才真
| 或:全假才假
^異或:相同為0 不同為1
~ 非: 非0為1,非1為0
優先級控制:如果運算式的運算比較復雜,需要控制優先級,可以使用小括號
拓展:instanceof

10.流程控制

1.順序結構

是指程式按照順序一行一行向下執行,可以用來進行輸入輸出計算等的操作
但是,順序結構不可以完成先做判斷,再做選擇的流程,因為順序結構中所有的代碼都會被執行到

2.分支結構

單分支結構

if(判斷條件){
            如果判斷條件的結果為true,就執行此處代碼,不符合條件,此處跳過
 }

多分支結構

if(判斷條件){
    如果判斷條件的結果為true,就執行此處的代碼
}else{
    如果不符合條件,執行else處的代碼
}

嵌套分支結構

if(判斷條件1){
    符合判斷條件1,執行此處代碼,不符合,繼續向下判斷
}else if(判斷條件2){
    符合判斷條件2,執行此處代碼,不符合,繼續向下判斷
}else if(判斷條件3){
    符合判斷條件3,執行此處代碼,不符合,繼續向下判斷
}else{
    保底選項,以上條件均不符合的情況下,執行此處代碼
}

練習題:嵌套分支的練習

需求:提示并接收用戶輸入的月份,判斷并輸出屬于哪個季節
1-12月是合法資料 3~5春天 6~8夏天 9~11秋天其他情況冬天

 package cn.tedu.basic;

import java.util.Scanner;

/*本類用于復習分支結構*/
public class TestIf {
    public static void main(String[] args) {
        //1.提示并接收用戶輸入的月份
        System.out.println("請輸入您要查看的月份:");
        int month = new Scanner(System.in).nextInt();

        //2.對用戶輸入的資料進行合法性檢測
        /*如果if后的陳述句只有一句,大括號可以省略不寫*/
        /*return關鍵字除了可以幫我們回傳方法的回傳值以外
        * 還可以直接結束當前的方法,如果遇到了return,本方法會直接結束*/
//        if(month <0 || month >12) return;
//        System.out.println("今天天氣真不錯");//這句話是用來檢測main()有沒有結束
        if(month <= 0 || month >12){
            System.out.println("您輸入的月份不正確!應該是1-12月以內");
        }else{
            //3.判斷接收到的合法資料屬于哪個季節,并將結果輸出
            if(month >=3 && month <=5){
                System.out.println(month+"月是春天");
            }else if(month >=6 && month <=8){
                System.out.println(month+"月是夏天~");
            }else if(month >=9 && month <=11){
                System.out.println(month+"月是秋天");
            }else{
                System.out.println("冬天就要來啦,春天還會遠嗎?");
            }
        }
    }
}

3.選擇結構

小括號中變數支持的型別:byte short char int String
注意: 如果配置了default默認選項,而且沒有任何的case被匹配到,就會執行default后的操作
case的個數是否加break 是否加default全部都是可選的,根據自己的具體業務做決定
小括號中變數的型別必須與case后value的型別一致
執行順序:先拿著變數的值,依次與每個case后的值做比較,如果相等,就執行case后的陳述句
若這個case后沒有break,就會繼續向下執行下一個case,如果一直沒有遇到break,就會發生穿透現象,包括default

switch (變數名){
            case value1 : 操作1;break;//可選
            case value2 : 操作2;break;//可選
            case value3 : 操作3;break;//可選
            case value4 : 操作4;break;//可選
            default:保底選項;//可選
        }

練習題:根據顏色推薦菜品switch

package cn.tedu.basic;

import java.util.Scanner;

/*本類用于復習switch*/
public class TestSwitch {
    public static void main(String[] args) {
        //需求:接收用戶今天輸入的顏色,推薦菜品
        //1.提示并接收用戶輸入的顏色
        System.out.println("請輸入您今天心情的顏色:");
        String color = new Scanner(System.in).nextLine();
        //2.完成選擇結構
        switch (color) {
            case "紅":
                System.out.println("紅燒魚");
                break;//為了避免穿透
            case "黃":
                System.out.println("菠蘿炒飯");
                break;
            case "橙":
                System.out.println("水煮肉片");
                break;
            default:
                System.out.println("哎呀,沒有識別到這個功能呢,正在開發中...");
        }
    }
}

4.回圈結構

可以幫我們多次重復的做某一件事
1.for回圈

for(開始條件;回圈條件;更改條件){
		如果符合回圈條件,就會執行回圈體里的內容
}

注意:我們定義的回圈變數,用來控制回圈,回圈變數可以取到幾個值,回圈就執行幾次
所以開始條件只會執行一次
注意:從哪開始到哪結束如何變化

for(開始條件;回圈條件;更改條件){//外層回圈
		for(開始條件;回圈條件;更改條件){//內層回圈
				回圈體
		}
}

注意:外層回圈控制的是行數,內層回圈控制的是列數
注意:外層回圈控制的是輪數,內層回圈控制的是在這一輪中執行的次數

2.while回圈

while(判斷條件){
		如果符合判斷條件,繼續回圈
}

注意:常用來完成死回圈,但死回圈必須設定出口!

練習題:while回圈練習

package cn.tedu.basic;

/*本類用作while復習*/
public class TestWhile {
    public static void main(String[] args) {
        //需求1:通過while回圈列印10次"小可愛們中午好~"
        f1();
        //需求2:通過while回圈列印1 2 3 ... 10
        f2();
        //需求3:通過while回圈列印1 3 5 7 9 ... 99
        f3();
        //需求4:通過while計算:1+2+3+4+...+10
        f4();
        //需求5:通過while計算:2+4+6+8...+100
        f5();
    }

    private static void f1() {
        //需求1:通過while回圈列印10次"小可愛們中午好~"
        //1.定義一個變數用來控制次數
        int count = 1;
        //2.定義一個回圈,結束條件是count>10
        while (count <= 10) {
            System.out.println("小可愛們中午好~");
            count++;//注意count的值需要自增,不然就是一個死回圈
        }
        System.out.println(count);//11
    }

    private static void f2() {
        //需求2:通過while回圈列印1 2 3 ... 10
        int i = 1;
        while (i <= 10) {
            System.out.println(i);
            i++;
        }
    }

    private static void f3() {
        //需求3:通過while回圈列印1 3 5 7 9 ... 99
        int num = 1;
        while (num < 100) {
            System.out.println(num);
            //num++;//12345...
            //num += 2;
            num = num + 2;//13579...
        }
    }

    private static void f4() {
        //需求4:通過while計算:1+2+3+4+...+10
        int i = 1;//用于控制回圈,相當于回圈變數
        int sum = 0;//用來保存求和的結果
        while(i <= 10){
            sum += i;
            //sum = sum + i;
            i++;
        }
        System.out.println("1到10累加的結果為:"+sum);
    }

    private static void f5() {
        //需求5:通過while計算:2+4+6+8...+100
        int i = 2;//回圈變數控制回圈
        int sum = 0;//用來保存求和的結果
        while(i <= 100){
            sum += i;//累加
            i += 2;//回圈變數遞增
        }
        System.out.println("2到100累加的結果為:"+sum);
    }
}

3.do-while回圈

do{
		回圈體
}while(判斷條件);

11. 方法

格式: 修飾符回傳值型別方法名(引數串列){ 方法體 }
如何確定我們要呼叫哪個方法呢?方法名+引數串列
如果一個方法被呼叫,就會執行這個方法里的內容,執行完畢,再回傳到呼叫的位置,從哪里呼叫,就回傳到哪里
如果這個方法有回傳值,我們有兩種選擇:
1. 選擇只執行功能,不接識訓傳值,不再繼續使用這個方法的結果
2. 選擇在方法呼叫的位置接收這個方法的回傳值,接收到的回傳值可以在方法外繼續使用
方法的多載:在同一個類中出現多個方法名相同,但引數串列不同的方法
注意:方法是否構成多載,取決于引數串列中引數的個數與引數的型別,與引數的名字無關
多載的意義: 多載不是為了程式員方便,而是為了方便外界呼叫這個名字的方法時
不管傳入什么型別的引數,都可以匹配到對應的方法來執行,程式會更加的靈活
方法的傳值 : 如果方法的引數型別是基本型別,傳入的是實際的字面值,如果是參考型別,傳入的是地址值
形參:形式意義上的引數,比如方法引數串列的引數名,光看引數名是無法確定這個變數的值是多少的
實參:實際意義上的引數,比如我們的區域變數,比如成員變數,比如呼叫方法時傳入的數字
方法的重寫: 子類繼承了父類以后,想要在不改變父類代碼的情況下,實作功能的修改與拓展
重寫遵循的規則:兩同兩小一大
一大: 子類方法的修飾符權限 >= 父類方法的修飾符權限
兩同: 方法名與引數串列與父類方法保持一致
兩小: 子類方法的回傳值型別 <= 父類方法的回傳值型別,注意:這里的<=說的是繼承關系,不是值的大小
子類方法拋出的例外型別 <= 父類方法拋出的例外型別
拓展 : 方法的遞回

練習題:方法呼叫的順序

package cn.tedu.basic;
/*本類用于練習方法的呼叫*/
public class MethodDemo {
    //1.創建入口函式
    public static void main(String[] args) {
        System.out.println("main() is start...");
        m1();
        System.out.println("main() is stop...");
    }

    //2.創建m1()
    private static void m1() {
        System.out.println("m1() is start...");
        m2();
        System.out.println("m1() is stop...");
    }
    //3.創建m2()
    private static void m2() {
        System.out.println("m2() is start...");
    }

}

12. 陣列

陣列的創建方式:
靜態創建 int[] a = {1,2,3,4,5};
靜態創建 int[] a = new int[]{1,2,3,4,5};
動態創建 int[] a = new int[5]; 后續可以動態的給陣列中的元素賦值
注意:不管是什么樣的創建方式,都需要指定陣列的型別與長度
我們可以通過陣列的下標來操作陣列中的元素
陣列下標從0開始,最大下標是陣列的長度-1,如果訪問到了不是這個陣列的下標,會出現陣列下標越界例外
比如:a[5]表示的就是陣列中的第6個元素
陣列的長度:陣列一旦創建,長度不可改變,長度指的是陣列中元素的個數a.length,并且陣列的長度允許為0:[ ]
陣列的創建程序:
1. 根據陣列的型別與長度開辟一塊連續的記憶體空間
2. 對陣列中的每個元素進行初始化,比如int陣列的默認值就是0
3. 生成陣列唯一的一個地址值,交給應用型別變數a來保存
4. 后續可以根據陣列的下標再來操作陣列中的具體元素
  注意: 陣列名a這個變數,保存的是陣列的地址,不是陣列中的具體元素
陣列的工具類Arrays
1. toString(陣列名) : 除了char型別的陣列以外,其他型別的陣列想要查看具體元素,需要使用本方法,否則列印的是地址值
2. copyOf(原陣列名,新陣列的長度) : 用來實作陣列的復制擴容縮容
  如果新陣列的長度 > 原陣列長度,就擴容,反之,則縮容,如果兩者長度一致,就是普通的復制陣列
  注意:一定是創建了新陣列,而不是對原陣列的長度做操作
陣列的遍歷
一般習慣使用for回圈,回圈變數代表的就是陣列的下標,從0開始,最大值是a.length-1
冒泡排序 :
外層回圈控制比較的輪數,所以回圈變數從1到n-1輪,代表的是輪數
內層回圈控制的是這一輪中比較的次數,而且是陣列中兩個相鄰元素的比較,所以回圈變數代表的是陣列的下標

練習題: 陣列練習1

需求1: 求陣列中所有元素之和
需求2: 求陣列中所有元素的最大值

package cn.tedu.basic;

/*本類用于復習陣列的操作*/
public class TestArray1 {
    public static void main(String[] args) {
        //需求1:求出陣列中所有的元素之和
        f1();
        //需求2:求出陣列中所有元素的最大值
        f2();
    }

    private static void f2() {
        //需求2:求出陣列中所有元素的最大值
        //1.定義一個陣列
        int[] a = {45, 8, 90, 34, 65, -9};
        //2.定義一個變數,用來存盤結果,也就是陣列中所有元素的最大值
        int max = a[0];//這個位置不能寫0,應該是陣列中第一個元素的值
        //3.遍歷陣列,比較出最大值
        for (int i = 0; i <= a.length - 1; i++) {
            //4.判斷max與a[i]的大小
            if(a[i] > max){
                max = a[i];//讓max保存的一直都是目前遍歷到的最大值
            }
        }
        //4.回圈結束,輸出陣列中的最大值
        System.out.println("最大值為:"+max);
    }

    private static void f1() {
        //需求1:求出陣列中所有的元素之和
        //1.定義一個陣列
        int[] a = {1, 2, 3, 4, 5};
        //2.定義一個變數用來保存最終的結果
        int sum = 0;
        //3.用陣列的遍歷來進行資料的累加
        //i:下標 0 a.length-1 ++
        for (int i = 0; i <= a.length - 1; i++) {
            sum += a[i];
        }
        System.out.println("陣列元素累計的和為:" + sum);
    }
}

練習題: 陣列練習2

需求: 將陣列中的所有元素逆序輸出(3種)
package cn.tedu.basic;

import java.util.Arrays;

/*需求: 將陣列中的所有元素逆序輸出(3種)*/
public class TestArray2 {
    public static void main(String[] args) {
        //f1();//實作思路1
        //f2();//實作思路2
        f3();//實作思路3
    }

    private static void f3() {
        //1.準備原陣列
        int[] a = {100, 200, 300, 400, 500, 600};
        //2.遍歷陣列,將陣列中對應位置上的元素交換位置
        for (int i = 0; i < a.length / 2; i++) {
            //3.準備一個第三方變數協助陣列中的兩個元素互換值
            //a[0] <-> a[a.length-1-0]
            //a[1] <-> a[a.length-1-1]
            //a[2] <-> a[a.length-1-2]
            //a[i] <-> a[a.length-1-i]
            int temp = a[i];
            a[i] = a[a.length-1-i];
            a[a.length-1-i] = temp;
        }
        System.out.println(Arrays.toString(a));
    }

    private static void f2() {
        //1.準備原陣列
        int[] a = {10, 20, 30, 40, 50};
        //2.準備一個新陣列,陣列的長度與原陣列長度相同
        int[] b = new int[a.length];
        //3.準備回圈,遍歷原陣列,并將遍歷到的元素復制到新陣列中
        //i=0,a[0]->b[4]
        //i=1,a[1]->b[3]
        //i=2,a[2]->b[2]
        //i=3,a[3]->b[1]
        //i=4,a[4]->b[0]
        for (int i = 0; i < a.length; i++) {
            b[b.length - 1 - i] = a[i];
        }
        System.out.println(Arrays.toString(b));
        a = b;//把b保存的地址值交給a,這樣a b兩個參考型別變數保存的是同一個陣列的地址值
        System.out.println(Arrays.toString(a));
    }

    private static void f1() {
        //1.準備陣列
        int[] a = {1, 2, 3, 4, 5};
        //2.倒著輸出
        //i:下標 從哪開始a.length-1  到哪結束0  如何變化--
        for (int i = a.length - 1; i >= 0; i--) {
            //3.把當前遍歷到的元素輸出
            System.out.println(a[i]);
        }
    }
}

2面向物件OOP

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/299522.html

標籤：java

上一篇：談談你對Spring IOC的理解【建議收藏】

下一篇：Codeforces 1365D Solve The Maze

CGBTN2108復習匯總

CGBTN2108復習匯總

復習思路:

一階段學習路徑：

1 基礎語法Basic

1.環境的配置

2.JDK JRE JVM

3. 語法基礎

1.關鍵字 :

2.識別符號 :

3.注釋 :

4 變數:

成員變數:類里方法外,類消失,成員變數才會消失

區域變數:方法里/代碼塊里,當區域代碼結束,區域變數也隨之釋放

變數的就近原則:離誰近 就使用誰

5 八大基本型別:

6.字面值規則:

練習題:進制的前綴

7.運算規則:

8.型別轉換

練習題:型別之間的轉換與字面值規則

9.運算子

練習題:==比較的練習

10.流程控制

1.順序結構

2.分支結構

練習題:嵌套分支的練習

3.選擇結構

練習題:根據顏色推薦菜品switch

4.回圈結構

練習題:while回圈練習

11. 方法

練習題:方法呼叫的順序

12. 陣列

練習題: 陣列練習1

練習題: 陣列練習2

2面向物件OOP

`一階段學習路徑：`

變數的就近原則:離誰近就使用誰