一、類與對象

1. 類和對象的區(qū)別和聯(lián)系

（1）類是抽象的，概念的，代表一類事物，比如人類、貓類...?即它是數(shù)據(jù)類型。

（2）對象是具體的，實際的，代表一個具體事物，即實例。

（3）類是對象的模板，對象是類的一個個體，對應一個實例。

2. 屬性/成員變量/字段

屬性是類的一個組成部分，一般是基本數(shù)據(jù)類型，也可是引用類型(對象，數(shù)組)。屬性如果不賦值，有默認值。

3. 成員方法

（1）當程序執(zhí)行到方法時，就會開辟一個獨立的空間（?？臻g）。
（2）當方法執(zhí)行完畢，或者執(zhí)行到return語句時，就會返回。
（3）返回到調用方法的地方。
（4）返回后，繼續(xù)執(zhí)行方法后面的代碼。
（5）當 main 方法（棧）執(zhí)行完畢，整個程序退出。

成員方法的定義：

訪問修飾符? 返回數(shù)據(jù)類型? 方法名 （形參列表..） {//方法體

????????語句；

????????return 返回值;

}

二、遞歸（P215）

遞歸重要規(guī)則
（1）執(zhí)行一個方法時，就創(chuàng)建一個新的受保護的獨立空間（?？臻g）。
（2）方法的局部變量是獨立的，不會相互影響，比如 n 變量。
（3）如果方法中使用的是引用類型變量（比如數(shù)組，對象），就會共享該引用類型的數(shù)據(jù)。
（4）遞歸必須向退出遞歸的條件逼近，否則就是無限遞歸，出現(xiàn) StackOverflowError。
（5）當一個方法執(zhí)行完畢，或者遇到 return，就會返回，遵守誰調用，就將結果返回給誰，同時當方法執(zhí)行完畢或者返回時，該方法也就執(zhí)行完畢。

1. 階乘

public class Demo {

    public static void main(String[] args) {
        int res = factorial(5);
        System.out.println("5 的階乘 res =" + res);
    }

    //factorial 階乘
    public static int factorial(int n) {
        if (n == 1) {
            return 1;
        } else {
            return factorial(n - 1) * n;
        }
    }

}

2. 斐波那契數(shù)

public class Demo {

    public static void main(String[] args) {
        int n = 7;
        System.out.println("當 n=" + n + " 對應的斐波那契數(shù)=" + fibonacci(n));
    }

    /**
     * 請使用遞歸的方式求出斐波那契數(shù) 1,1,2,3,5,8,13...給你一個整數(shù) n，求出它的值是多
     */
    public static int fibonacci(int n) {
        if (n == 1 || n == 2) {
            return 1;
        } else {
            return fibonacci(n - 1) + fibonacci(n - 2);
        }
    }

}

3. 猴子吃桃問題（P221）

public class Demo {

    public static void main(String[] args) {
        //桃子問題
        int day = 1;
        int peachNum = peach(day);
        if (peachNum != -1) {
            System.out.println("第 " + day + "天有" + peachNum + "個桃子");
        }
    }

    /**
     * 猴子吃桃子問題：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一個！
     * 以后每天猴子都吃其中的一半，然后再多吃一個。當?shù)降?10 天時，
     * 想再吃時（即還沒吃），發(fā)現(xiàn)只有 1 個桃子了。問題：最初共多少個桃子？
     */
    public static int peach(int day) {
        if (day == 10) {//第 10 天，只有 1 個桃
            return 1;
        } else if (day >= 1 && day <= 9) {
            return (peach(day + 1) + 1) * 2;//規(guī)則，自己要想
        } else {
            System.out.println("day 在 1-10");
            return -1;
        }
    }

}

4. 老鼠迷宮（P222）

public class Migong {
    public static void main(String[] args) {
 
        int[][] map = new int[8][7];
        for (int i = 0; i < 7; i++) {
            map[0][i] = 1;
            map[7][i] = 1;
        }
 
        for (int i = 0; i < 8; i++) {
            map[i][0] = 1;
            map[i][6] = 1;
        }
 
        map[3][1] = 1;
        map[3][2] = 1;
        map[2][2] = 1;
        
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[i].length; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
 
        T t = new T();
        boolean way = t.findWay(map, 1, 1);
        System.out.println("---------找路地圖--------");
        // 找路地圖
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[i].length; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
    }
}
 
 
class T{
 
    // 0:可以走 1:障礙物 2:可以走 3:走過但是走不通
    // (6,5) = 2 說明成功
    // 策略 下 > 右 > 上 > 左
    public boolean findWay(int[][] map,int i ,int j){
 
        if (map[6][5] == 2){
            return true;
        }else {
            if (map[i][j] == 0){ // 當前位置為0，可以走
                // 假設可以走
                map[i][j] = 2;
                if (findWay(map,i+1,j)){
                    return true;
                }else if (findWay(map,i,j+1)){
                    return true;
                }else if (findWay(map,i-1,j)){
                    return true;
                }else if (findWay(map,i,j-1)){
                    return true;
                }else {
                    map[i][j] = 3;
                    return false;
                }
 
            }else { // map[i][j] == 1,2,3
                return false;
            }
        }
 
 
    }
}

三、方法重載（OverLoad）

java 中允許同一個類中，多個同名方法的存在，但要求形參列表不一致！

注意事項和使用細節(jié)：

（1）方法名：必須相同
（2）形參列表：必須不同（形參類型或個數(shù)或順序，至少有一樣不同，參數(shù)名無要求）。
（3）返回類型：無要求

四、可變參數(shù)

java 允許將同一個類中多個同名同功能但參數(shù)個數(shù)不同的方法，封裝成一個方法。 就可以通過可變參數(shù)實現(xiàn)。

基本語法
????????訪問修飾符 返回類型 方法名（數(shù)據(jù)類型... 形參名）{

}

public class Demo {

    public static void main(String[] args) {
        System.out.println(sum(1, 5, 100)); //106
        System.out.println(sum(1, 19)); //20
    }

    //1. int... 表示接受的是可變參數(shù)，類型是 int ,即可以接收多個 int(0-多)
    //2. 使用可變參數(shù)時，可以當做數(shù)組來使用 即 nums 可以當做數(shù)組
    //3. 遍歷 nums 求和即可
    public static int sum(int... nums) {
        int res = 0;
        for (int i = 0; i < nums.length; i++) {
            res += nums[i];
        }
        return res;
    }

}

注意事項和使用細節(jié)

（1）可變參數(shù)的實參可以為 0 個或任意多個。
（2）可變參數(shù)的實參可以為數(shù)組。
（3）可變參數(shù)的本質就是數(shù)組。
（4）可變參數(shù)可以和普通類型的參數(shù)一起放在形參列表，但必須保證可變參數(shù)在最后。
（5）一個形參列表中只能出現(xiàn)一個可變參數(shù)。

五、構造方法/構造器

1. 基本語法

[修飾符] 方法名(形參列表){

????????方法體;

}

（1）構造器的修飾符可以默認， 也可以是 public protected private。
（2）構造器沒有返回值。
（3）方法名和類名字必須一樣。
（4）參數(shù)列表和成員方法一樣的規(guī)則。
（5）構造器的調用，由系統(tǒng)完成。

2. 基本介紹

構造方法又叫構造器(constructor)，是類的一種特殊的方法，它的主要作用是完成對新對象的初始化。它有幾個特點：

（1）方法名和類名相同
（2）沒有返回值
（3）在創(chuàng)建對象時，系統(tǒng)會自動的調用該類的構造器完成對象的初始化。

3. 注意事項和使用細節(jié)

（1）一個類可以定義多個不同的構造器，即構造器重載。
（2）構造器名和類名要相同。
（3）構造器沒有返回值。
（4）構造器是完成對象的初始化，并不是創(chuàng)建對象。
（5）在創(chuàng)建對象時，系統(tǒng)自動的調用該類的構造方法。
（6）如果程序員沒有定義構造器，系統(tǒng)會自動給類生成一個默認無參構造器（也叫默認構造器）。

（7）一旦定義了自己的構造器，默認的構造器就覆蓋了，就不能再使用默認的無參構造器，除非顯式的定義一下。

六、this 關鍵字（P246）

Java 虛擬機會給每個對象分配 this，代表當前對象。

this 的注意事項和使用細節(jié)：

（1）this 關鍵字可以用來訪問本類的屬性、方法、構造器。
（2）this 用于區(qū)分當前類的屬性和局部變量。
（3）訪問成員方法的語法：【this.方法名(參數(shù)列表);】。
（4）訪問構造器語法：【this(參數(shù)列表);】 注意只能在構造器中使用（即只能在構造器中訪問另外一個構造器, 必須放在第一條語句）。
（5）this 不能在類定義的外部使用，只能在類定義的方法中使用。文章來源地址http://www.zghlxwxcb.cn/news/detail-455259.html

到了這里，關于第七章 面向對象編程（基礎）的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網(wǎng)！