java学习笔记（2023/2/7）--函数

函数的定义

public static 数据类型 函数名（参数）{}

出void外其他类型需要return。

函数的调用过程

定义的函数会储存在栈内存里面。函数的调用就是压栈的过程，在执行完后就是出栈。

可以通过栈帧链分析函数调用的过程

 主要意思是在定义的函数里面调用上一个定义的函数来分析最终函数的进栈出栈过程

在这里可以看到函数进栈顺序。

出栈顺序如下：

函数的重载

可以重载的条件：

函数都在同一个类里面；

函数名相同，数据类型不同，传递参数个数不同

需要注意的是：

重载的区别只发生在定义，调用时没有任何区别。

函数的重载只发生在名称和参数的识别，返回类值类型不能拿来判断函数是否重载 。

ps：理解上的错误：数据类型也不能拿来重载的识别（实际上还是返回类型）

eg：

 它俩的数据类型相同，区别就是参数个数，但是程序没报错误。

形参和实参

形参：函数定义的参数

eg: sum(int a,int b)

实参：函数调用的参数

eg：sum(a,b)

简单来说，形参就是新开辟的一块空间，跟实参的毫无关联，所以形参的改变影响不了实参，包括交换数值，改变数值等。

ps：数组属于引用类型。

关于函数和数组的小练习：

设计一个可输入的数组，可控制输入，遍历这个数组并且找到最大元素，最后通过冒泡升序，选择降序。

package com.code;
import java.util.Scanner;
public class method {
    public static void main(String[] args) {
        int[] arr = new int[10];
        inputArr(arr);//输入数组
        outputArr(arr);//输出数组
        System.out.println("\n最大值是：" + getMax(arr));//找最大值
        sortArr(arr);//排序
    }
    public static void inputArr(int arr[]){
        int flag;//输入flag的值判断输入继续输入数组元素
        Scanner sr = new Scanner(System.in);
        for (int i = 0; i < 10; i++) {
            System.out.print("输入数组元素：0-继续，1-结束");
            flag = sr.nextInt();
            if (flag == 1)
                break;
            else if (flag != 1 & flag != 0) {
                System.out.println("输入值不在范围内，请重新确认！");
                i--;
                continue;
            }
            System.out.print("输入数组元素");
            arr[i] = sr.nextInt();
        }

    }
    public static int getMax(int arr[]) {
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max)
                max = arr[i];
        }
        return max;
    }
    public static void outputArr(int arr[]){
        System.out.println("数组元素是：");
        for(int i=0;i<arr.length;i++)
        {
            System.out.print(arr[i]);
            if(i<arr.length-1)
                System.out.print(",");
        }
    }
    public static void sortArr(int arr[]){
        System.out.println("冒泡升序");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
            for(int n=0;n<arr.length;n++)
            {
                System.out.print(arr[n]);
                if(n<arr.length-1)
                    System.out.print(",");
            }
            System.out.println("\n选择降序");
            for(int a=0;a<arr.length;a++)
            {
                int max_number=a;
                for(int b=a+1;b<arr.length-a;b++)
                {
                    if(arr[max_number]<arr[b])
                    {
                       max_number=b;
                    }
                }
                if(max_number!=a)
                {
                    int temp=arr[a];
                    arr[a]=arr[max_number];
                    arr[max_number]=temp;
                }
            }
            for(int n=0;n<arr.length;n++)
            {
                System.out.print(arr[n]);
                if(n<arr.length-1)
                    System.out.print(",");
            }

    }

这里需要注意的是，输入flag信号不在0和1的时候，如果只使用continue虽然可以返回到判断部分，但是这里的i是要++的，所以在执行continue之前要i--来维持i不变。 

 eg：

 

 这里就可以说明continue之后i会发生自增。

输出样例：

对选择排序掌握不熟练