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

2023-12-21 18:36:55

一、类与对象

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://blog.csdn.net/yirenyuan/article/details/135135993
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。