java基础4

一、类与对象

类与对象的区别和联系

在这里插入图片描述

对象在内存中的存在形式

注意：String 是引用类型，所以堆中的name和color存放的是地址，指向常量池中的常量
在这里插入图片描述

属性/成员变量

注意事项和细节

在这里插入图片描述

如何创建对象

1、先声明再创建

Cat cat;//声明了一个对象，在栈中，指向null
cat = new Cat();// 在堆中开辟了一个空间，同时把栈中的引用变量cat指向堆中地址
1
2

2、直接创建

Cat cat = new Cat();
1

类和对象的内存分配机制（重要）

在这里插入图片描述

二、方法

方法的调用机制（重要）

当程序执行到方法的时候会开辟一个独处的栈空间

如：
在这里插入图片描述

成员方法的细节

在这里插入图片描述

成员方法传参机制（重要）

在这里插入图片描述
结论： 基本数据类型传递的是值传递（值拷贝），形参的任何改变不影响实参

结论： 引用类型传递的是地址（地址拷贝），可以通过形参影响实参

补充：引用数据类型分3种：类，接口，数组
类：Object，String，Date，Void

克隆对象

public class test {
    public static void main(String[] args) {
        Person p = new Person();
        p.name = "aaa";
        p.age = 26;
        Mytools tools = new Mytools();
        Person p2 = tools.copy(p);
    }
}

class Person {
    String name;
    int age;
}

class Mytools {
    public Person copy(Person p) {
        Person p2 = new Person();
        //如果是 Person p2 = p;则不是拷贝一个新对象了，而是拷贝了地址
        p2.name = p.name;
        p2.age = p.age;
        return p2;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

方法的递归调用（栈）

在这里插入图片描述

递归的重要规则

黑马程序员 - Java基础教学 - 04 - 数组、进制转换、二维数组

doc

5星超过95%的资源 93KB

下载

在这里插入图片描述

解决递归问题：三步曲

第一步，定义函数功能
第二步，寻找递归终止条件
第二步，递推函数的等价关系式

迷宫问题

public class test {
    public static void main(String[] args) {
        //定义迷宫，0代表无障碍，1代表有障碍，2代表能走，3代表走过走不通
        int[][] arr = new int[8][7];
        for (int i = 0; i < 7; i++) {
            arr[0][i] = 1;
            arr[7][i] = 1;
        }
        for (int i = 1; i < 7; i++) {
            arr[i][0] = 1;
            arr[i][6] = 1;
        }
        arr[2][1] = 1;
        arr[2][2] = 1;
        arr[3][2] = 1;
        arr[3][3] = 1;
//        arr[1][2] = 1;
        Mouse mouse = new Mouse();
        mouse.findWay(arr, 1, 1);
        for (int[] i : arr) {
            for (int j : i) {
                System.out.print(j + " ");
            }
            System.out.println("");
        }
    }
}

class Mouse {
    //定义规则，下右上左
    Boolean findWay(int[][] arr, int i, int j) {
        //递归终止条件:能走出，出口标志位为2或者四个方向都不能走标志位为3
        if (arr[6][5] == 2) {
            return true;
        } else {
            if (arr[i][j] == 0) {
                //假定可以走通
                arr[i][j] = 2;
                if (findWay(arr, i + 1, j)) {
                    return true;
                } else if (findWay(arr, i, j + 1)) {
                    return true;
                } else if (findWay(arr, i - 1, j)) {
                    return true;
                } else if (findWay(arr, i, j - 1)) {
                    return true;
                } else {
                    //上下左右都不能走，则假定失败，标志位为3
                    arr[i][j] = 3;
                    return false;
                }
            } else {
                return false;
            }

        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

汉诺塔

/*上述可以看出，每次都会有将最大的一个从A移动到C的步骤。假如有n（n>1）个需要移动的盘子，我们可以将这些步骤分为3步：
1、将1到n-1的盘子通过C的辅助从A移动到B
2、将第n个盘子移动到C
3、将1到n-1个盘子通过A辅助从B移动到C*/
class HanoiTower {
    void move(int num, char a, char b, char c) {
        if (num == 1) {
            System.out.println(a + "==>" + c);
        } else {
            move(num - 1, a, c, b);
            System.out.println(a + "==>" + c);
            move(num - 1, b, a, c);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15