java基础_day05

方法的内存展示

java的内存分区

java将内存分成了5块儿,分别是堆区,栈区,方法区,本地方法区,寄存器
栈区:里面存放数据的特点是:先进后出,我们主要将加载时的局部变量和函数放在栈区,数据的特点是使用完立刻释放
堆区:存放的是实体(对象和数组),实体可以同时存放多个值,实体里面的变量如果不赋值,会有默认值.整型数据默认值是0,boolean---false
了解:
方法区:程序运行中的二进制文件等(比如:.class)
本地方法区:存放外界引入的c,c++等的内容
寄存器:也可以称为计数器.
堆区中的数据会在某个时刻被释放-通过垃圾回收机制.
垃圾回收机制是通过一个线程控制的,由于这个线程的等级比较低,所以不会立刻执行,数据就
不会立刻释放.

方法的重载(会)

什么是方法的重载
定义：同一个类中，方法名字相同，参数列表不同，就叫方法重载
说明：
1. 参数列表的不同包括，参数个数不同，参数数据类型不同，参数顺序不同
2. 方法的重载与方法的修饰符和返回值没有任何关系

方法的递归(会)

定义：在一个方法内，调用方法本身，称为方法的递归(注意和重载的区别)
说明：方法递归包含了一种隐式的循环，会重复执行某段代码，但是这种重复不需要使用循环语句来进行控制

数组

1 数组的定义

1.数组中可以存储基本数据类型的数据， 也可以存储引用数据类型的数据。
2.数组的长度是不可变的,数组的内存空间是连续的。 一个数组一旦实例化完成， 长度不能改变。

2 比较简单和引用数据类型

1.引用数据类型里面存储的是地址,并且这个地址是十六进制的数.简单数据类型存储的是值,是十进制的
2.对于简单数据类型,直接在栈区的方法中开辟一块空间存储当前的变量,将要存储的数据直接放在这块空间里
​
​

3 数组的声明(会)

public class Test {
    public static void main(String[] args) {
        int a = 5;
// 声明一个数组， 存储若干个double类型的数据
    double[] array1;
// 声明一个数组， 存储若干个int类型的数据
    int[] array2;
// 声明一个数组， 存储若干个String类型的数据
    String[] array3;
    }
}
​

4 数组引用

数组的实例化的时候， 需要使用到关键字new
以后但凡是遇到了new, 都表示在堆上开辟空间！
数组， 其实是在堆上开辟的连续的空间。 例如 new int[5] ， 就是在堆上开辟5个连续的4
字节空间。然后， 将堆上的内存地址， 赋值给栈上的变量array(引用)。

5 数组的下标(会)

下标， 就是数组中的元素在数组中存储的位置索引。
注意： 数组的下标是从0开始的， 即数组中的元素下标范围是 [0, 数组.length - 1]

6 访问数组元素

public class Test {
    public static void main(String[] args) {
// 实例化一个数组
        int[] array = { 1, 2, 3, 4, 5 };
// 访问数组中的元素
            array[2] = 300; // 将数组中的第2个元素修改成300， 此时
数组中的元素是 [ 1, 2, 300, 4, 5 ]
            System.out.println(array[2]); // 获取数组中的第2个元素， 此时的输出
结果是 300
    }
}
/注意：在访问数组中的元素的时候， 注意下标的问题！
如果使用错误的下标访问数组中的元素， 将会出现 ArrayIndexOutOfBoundsException异常！

7 数组的遍历(会)

7.1 增强for循环

//思路： 依次使用数组中的每一个元素， 给迭代变量进行赋值。
public class Test {
    public static void main(String[] args) {
// 实例化一个数组
    int[] array = { 1, 2, 3, 4, 5 };
// 依次使用数组中的每一个元素， 给迭代变量进行赋值。
// 此时， 数组中的每一个元素依次给 element 进行赋值。
    for (int element : array) {
    System.out.println(element);
        }
    }
}

7.2 . 下标遍历

//思路： 循环依次获取数组中的每一个下标， 再使用下标访问数组中的元素
public class Test {
    public static void main(String[] args) {
// 实例化一个数组
    int[] array = { 1, 2, 3, 4, 5 };
// 使用下标遍历数组
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
        }
    }
}

7.3 两种方式的对比

​
如果需要在遍历的同时， 获取到数组中的元素下标， 需要使用下标遍历法。
如果需要在遍历的同时， 修改数组中的元素， 需要使用下标遍历法。
如果仅仅是想要获取数组中的每一个元素， 不需要下标， 也不需要修改数组中的元素，
使用增强for循环。 因为这种方式， 遍历的效率比下标遍历法高。

8 函数和数组的联合应用(会)

8.1 函数传参分类

值传递:将保存简单数据的变量作为参数传递
址传递:将保存地址的变量作为参数传递
址传递优点:让我们可以实现使用一个变量一次传递多个值
​
public class Demo3 {
public static void main(String[] args) {
//求三个数的和
//直接用数值作为参数传递-值传递
int tmp1 = getMax(3, 4, 6);
System.out.println(tmp1);
//用数组实现求三个数的和-址传递
int[] arr1 = new int[] {3,5,8};
int tmp2 = getMax(arr1);
System.out.println(tmp2);
}
public static int getMax(int a,int b,int c) {//值传递
int tmp = a>b?a:b;
return c>tmp?c:tmp;
}
public static int getMax(int[] arr) {//地址传递 arr = arr1
int max = arr[0];
for (int i=0;i<arr.length-1;i++) {
if (max < arr[i+1]) {
max = arr[i+1];
}
}
return max;
}
}
​

8.2 址传递的深入理解(扩展)

值传递和址传递比较
通过值作为参数传递,函数内部值的变量不会改变外部的值.
通过地址作为参数传递,函数内部值的变量可以直接改变外部值.
public class Demo4 {
    public static void main(String[] args) {
//交换两个数的值
    int[] temp = {3,5};
//地址传递
    jiaohuan1(temp);
//我们发现通过址传递数组temp内的两个值发生了交换
System.out.println("temp[0]:"+temp[0]+"         temp[1]:"+temp[1]);// 5 3
//值传递
int[] temp1 = {3,5};
jiaohuan2(temp1[0], temp1[1]);
//通过值传递数组temp内的两个值没有发生交换
System.out.println("temp1[0]:"+temp1[0]+"
    temp1[1]:"+temp1[1]);// 3 5
}
//地址传递
public static void jiaohuan1(int[] arr) {
    arr[0] = arr[0] ^ arr[1];
    arr[1] = arr[0] ^ arr[1];
    arr[0] = arr[0] ^ arr[1];
}
//值传递
public static void jiaohuan2(int a,int b) {
    a = a ^ b;
    b = a ^ b;
    a = a ^ b;
    }
}

                                                                                                                                           待续......