第七章 面向对象编程(基础)

一、类与对象

1. 类和对象的区别和联系

（1） 类是抽象的，概念的，代表一类事物， 比如人类、 猫类 … 即它是数据类型。
（2） 对象是具体的，实际的，代表一个具体事物 , 即实例 。
（3） 类是对象的模板，对象是类的一个个体，对应一个实例。

2. 属性/成员变量/字段

属性是类的一个组成部分，一般是基本数据类型，也可以是引用类型 ( 对象，数组 )。属性如果不赋值，有默认值。

3. 成员方法

（1）当程序执行到方法时，就会开辟一个独立的空间（栈空间）。
（2）当方法执行完毕，或者执行到 return 语句时，就会返回。
（3）返回到调用方法的地方。
（4）返回后，继续执行方法后面的代码。
（5）当 main 方法（栈）执行完毕，整个程序退出。

成员方法的定义：
访问修饰符  返回数据类型  方法名 （形参列表 .. ） {// 方法体
        语句；
        return 返回值 ;
}

二、递归（P215）

递归重要规则
（1）执行一个方法时，就创建一个新的受保护的独立空间（栈空间）。
（2）方法的局部变量是独立的，不会相互影响，比如 n 变量。
（3）如果方法中使用的是引用类型变量（比如数组，对象），就会共享该引用类型的数据。
（4）递归必须向退出递归的条件逼近，否则就是无限递归，出现 StackOverflowError。
（5）当一个方法执行完毕，或者遇到 return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。

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. 斐波那契数

public class Demo {
 
    public static void main(String[] args) {
        int n = 7;
        System.out.println("当 n=" + n + " 对应的斐波那契数=" + fibonacci(n));
    }
 
    /**
     * 请使用递归的方式求出斐波那契数 1,1,2,3,5,8,13...给你一个整数 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 + "个桃子");
        }
    }
 
    /**
     * 猴子吃桃子问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个！
     * 以后每天猴子都吃其中的一半，然后再多吃一个。当到第 10 天时，
     * 想再吃时（即还没吃），发现只有 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;//规则，自己要想
        } 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 中允许同一个类中，多个同名方法的存在，但要求形参列表不一致！

注意事项和使用细节：
（1）方法名：必须相同
（2）形参列表：必须不同（形参类型或个数或顺序，至少有一样不同，参数名无要求）。
（3）返回类型：无要求

四、可变参数

java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。 就可以通过可变参数实现。

基本语法
访问修饰符 返回类型 方法名（数据类型... 形参名）{

}

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... 表示接受的是可变参数，类型是 int ,即可以接收多个 int(0-多)
    //2. 使用可变参数时，可以当做数组来使用 即 nums 可以当做数组
    //3. 遍历 nums 求和即可
    public static int sum(int... nums) {
        int res = 0;
        for (int i = 0; i < nums.length; i++) {
            res += nums[i];
        }
        return res;
    }
 
}

注意事项和使用细节
（1）可变参数的实参可以为 0 个或任意多个。
（2）可变参数的实参可以为数组。
（3）可变参数的本质就是数组。
（4）可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后。
（5）一个形参列表中只能出现一个可变参数。

五、构造方法/构造器

1. 基本语法

[ 修饰符 ] 方法名 ( 形参列表 ){
        方法体;
}

（1） 构造器的修饰符可以默认， 也可以是 public protected private。
（2） 构造器没有返回值。
（3） 方法名和类名字必须一样。
（4） 参数列表和成员方法一样的规则。
（5） 造器的调用， 由系统完成。

2. 基本介绍

构造方法又叫构造器 (constructor) ，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：
（1） 方法名和类名相同
（2） 没有返回值
（3） 在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。

3. 注意事项和使用细节

（1）一个类可以定义多个不同的构造器，即构造器重载。
（2）构造器名和类名要相同。
（3）构造器没有返回值。
（4）构造器是完成对象的初始化，并不是创建对象。
（5）在创建对象时，系统自动的调用该类的构造方法。
（6）如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器（也叫默认构造器）。
（7）一旦定义了自己的构造器，默认的构造器就覆盖了，就不能再使用默认的无参构造器，除非显式的定义一下。

六、this 关键字（P246）

Java 虚拟机会给每个对象分配 this，代表当前对象。

this 的注意事项和使用细节：
（1） this 关键字可以用来访问本类的属性、方法、构造器。
（2） this 用于区分当前类的属性和局部变量。
（3） 访问成员方法的语法：【this. 方法名 ( 参数列表 );】。
（4） 访问构造器语法：【 this( 参数列表 );】 注意只能在构造器中使用（即只能在构造器中访问另外一个构造器, 必须放在第一条语句）。
（5） this 不能在类定义的外部使用，只能在类定义的方法中使用。