第七章面向对象编程（基础）-Toy模板网

这篇具有很好参考价值的文章主要介绍了第七章面向对象编程（基础）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一、类与对象

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 不能在类定义的外部使用，只能在类定义的方法中使用。文章来源地址https://www.toymoban.com/news/detail-455259.html

到了这里，关于第七章面向对象编程（基础）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！