方法、函数

2023-09-28 23:28:58

1、概念

概念：实现特定功能的一段代码，可反复使用。

2、定义

修饰符：public 、static 被称为修饰符
返回值类型：⽤来说明该⽅法运算结果的类型。如果返回其他类型，编译就可能出错
⽅法名：它作为调⽤时引⽤⽅法的标识
形参列表：在⽅法被调⽤时⽤于接受外部传⼊的变量称为形式参数简称为形参，⽅法的形参个数可以是0个到
多个，每个参数前⾯要声明参数的数据类型称为参数类型；每个参数要⽤逗号分开。也可以⼀个参数都没有
⽅法体：它是⼀个语句块，执⾏特定的功能操作。对于有返回值类型的⽅法，⽅法体当中最后⼀个语句是
return关键字，它的作⽤是把⽅法的执⾏（运算）结果返回到⽅法外部
return 表达式：return是关键字，作⽤是将return后⾯表达式的结果作为⽅法的返回值。需要注意表达式的
类型，必须与⽅法头中声明的“返回类型”相匹配

语法：
public static void 方法名(){
//方法主题
}
    
方法定义在类的内部，于main方法并列

示范：

    public static void main(String[] args) {
        xing();//调用xing方法
        System.out.println("床前明月光");
        xing();
        System.out.println("疑是地上霜");
        xing();
        System.out.println("举头望明月");
        xing();
        System.out.println("低头思故乡");
        xing();
    }

    public static void xing() {
        System.out.println("************");
    }

3、调用

分类

有参、无参、有返回值、无返回值

//⽆参⽆返回值的⽅法
public static void method1(){
System.out.println("我就是⾃娱⾃乐");
}
//有参⽆返回值的⽅法
public static void method2(int a){
//计算a平⽅
System.out.println(a*a);
}
//⽆参有返回值的⽅法
public static long method3(){
//获取当前时间
long time = System.currentTimeMillis();
return time;
}
//有参有返回值
public static int method4(int a,int b){
//返回a,b中数值较⼤的那个
return a>b?a:b;
}

调用方式
- 单独调用方法独立于其他代码，独立执行功能
  - 多用检测维护型的方法
- 输出调用只做结果输出，这种调用对我们来说没有任何意义
- 赋值调用有返回值结果，可以进行下一步操作

public static void main(String[] args) {
    //赋值调⽤
    int c = multipy(14, 15);
    System.out.println(c);
    //输出调⽤
    print();
    //单独调⽤
    clear();
}
//定义⽅法,计算两个数的乘积
public static int multipy(int a, int b){
    int count = a * b;
    return count;
}
//打印语句功能
public static void print(){
    System.out.println("哇,有美⼥....");
}
//清理系统垃圾功能
public static void clear(){
    for (int i = 0; i < 1000; i++) {
        System.out.println("系统清理中....");
    }
}

4、好处

减少代码冗余、提高复用性，可读性，可维护性，方便分工合作

5、重载

定义

一个类中出现多个方法名相同，参数列表不同的方法叫方法重载
参数列表
- 参数个数不同
- 参数类型不同
- 参数的顺序不同

public static void method(int i,double d){
}
//和第⼀个⽅法的参数个数不同
public static void method(int i){
}
//和第⼀个⽅法的参数的类型不同
public static void method(String str,float f){
}
//和第⼀个⽅法的参数的顺序不同
public static void method(double d,int i){
}

6、方法相互调用内存图

栈的定义
- 运行方法和存储局部变量
- 栈是一个一端开口的筒子，类似于羽毛球筒

执行流程

当JVM执行某个方法时，会将这个方法放到栈中运行。当这个方法调用其他方法时，JVM就会将新的方法也放入栈中已有的方法上面执行，当方法执行完毕后，方法就会被JVM从栈中移除，称为弹栈。

7、方法的参数

多数情况下，方法与调用者之间需要数据的交互；调用者必须提供必要的数据，才能使方法完成相应的功能。

参数作用：方法的参数可以让代码功能更灵活、普适性更高，易于修改及维护。

形参与实参

单个参数使用

需求：在多次调用xing方法时，可以打印不同次数的减号

    public static void main(String[] args) {
        xing(5);
        System.out.println("床前明月光");
        xing(10);
        System.out.println("疑是地上霜");
        xing(2);
        System.out.println("举头望明月");
        xing(15);
        System.out.println("低头思故乡");
        xing(5);

    }

    public static void xing(int count) {
        for (int i = 0; i <= count; i++) {
            System.out.print("*");
        }
        System.out.println();
    }

多个参数使用

需求：在多次调用xing方法时，可以打印不同次数的符号

    public static void main(String[] args) {
        xing(5,"*");
        System.out.println("床前明月光");
        xing(10,"+");
        System.out.println("疑是地上霜");
        xing(2,"&");
        System.out.println("举头望明月");
        xing(15,"%");
        System.out.println("低头思故乡");
        xing(5,"@");

    }

    public static void xing(int count,String hao) {
        for (int i = 0; i <= count; i++) {
            System.out.print(hao);
        }
        System.out.println();
    }

返回值和返回类型

概念：方法执行后的返回结果。
方法执行后，一些情况下无需返回结果；另一些情况下则必须返回结果。

示例：
需求：定义方法，计算两个整数的和，并返回结果，在main中打印。

public class work2 {
    public static void main(String[] args) {
        double add=countNum(51.1, 2);
        System.out.println(add);
    }

    public static double countNum(double num1, double num2) {
        double sum = num1 + num2;
        return sum;
    }

定义countNum方法有两个参数，让他们相加，使用return返回总和。通过调用countNum赋值给double num1, double num2。

每一个方法都有一个返回值，if语句等每一个分支都有一个返回值。

return的两种用法：
    应用在县有返回值类型的方法中：
        return value；//表示结束当前方法，并伴有返回值，返回到方法调用处。
    应用在没有返回值类型（void）的方法中：
        return；//表示结束当前方法，直接返回到方法调用处。

三个关键字

关键字	作用
continue	结束本次循环
break	结束整个循环，循环后面的代码继续执行
return	结束整个方法

8、数字作为参数、返回值

作为参数

数组作为方法参数传递，传递的参数是数组的内存地址

public static void main(String[] args) {
    int[] arr = { 1, 3, 5, 7, 9 };
    //调⽤⽅法，传递数组
    printArray(arr);
}
/* 创建⽅法，⽅法接收数组类型的参数 进⾏数组的遍历 */
public static void printArray(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}

作为返回值

数组作为⽅法的返回值，返回的是数组的内存地址

public static void main(String[] args) {
    //调⽤⽅法，接收数组的返回值
    //接收到的是数组的内存地址
    int[] arr = getArray();
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}
/*创建⽅法，返回值是数组类型
return返回数组的地址
*/
public static int[] getArray() {
    int[] arr = { 1, 3, 5, 7, 9 };
    //返回数组的地址，返回到调⽤者
    return arr;
}

⽅法的参数为基本类型时,传递的是数据值. ⽅法的参数为引⽤类型时,传递的是地址值.

9、可变参数

定义

中方法声明上使用，表示多个相同类型的参数
注意事项

在实际调用中，在方法内传入多个实参，虚拟机会自动帮我们填充到可变参数上，形成一个数组

示例

public void method(String... strs){
    for (int i = 0; i < strs.length; i++) {
        System.out.println(strs[i]);
    }
}
public static void main(String[] args) {
    Class class1 = new Class();
    class1.method("⼩明","⼩红","⼩时");
}

10、递归

递归

定义

递归就是处理有规律的问题，在方法内部再次调用自身方法
使用场景
- 当问题可以拆分成多个问题，大小问题的处理方法一致，方法调用自己本身
- 可以使用循环处理的常规问题，都可以使用递归处理
使用

必须设置出口，让每一个方法都可以正确的返回，不能无限调用

阶乘递归

需求：计算5的阶乘：5！=54321；

    public static void main(String[] args) {
        System.out.println(countNum(5));
    }

    public static int countNum(int n) {
        int num = 1;
        for (int i = 1; i <= n; i++) {
            num = num * i;
        }
        return num;
    }

递归计算

    public static void main(String[] args) {
        System.out.println(Five(5));
    }

    //5!=5*4!   n是5，Four(n - 1)返回给Four=4
    public static int Five(int n) {
        return n * Four(n - 1); //5*4*3*2*1    n=5
    }

    public static int Four(int n) {
        return n * Three(n - 1);    //4*3*2*1    n=4
    }

    public static int Three(int n) {
        return n * Two(n - 1);  //3*2*1    n=3
    }

    public static int Two(int n) {
        return n * one(n - 1);  //2*1    n=2
    }

    public static int one(int n) {
        return 1;    //1    n=1
    }

在编写中其实求阶乘的方法一直在重复，我们将重复的部分提取出来，优化程序。

    public static void main(String[] args) {
        System.out.println(Factorial(5));
    }
    //专门算阶乘的方法
    public static int Factorial(int n) {
        //设置程序递归的出口，否则会出现内存溢出错误
        if (n == 1) {
            return 1;
        }
        //5*4！，然后Factorial(n - 1)会调用自身，从而变成了4*3！，一直递归
        return n * Factorial(n - 1);
    }

Factorial是专门算阶乘的方法，自身调用自动，反复的递归，但是需要考虑程序的出口，也就是n=1的时候返回1，结束程序，不能使n=-1计算下去，否则会出现内存溢出报错。
ic void main(String[] args) {
System.out.println(Factorial(5));
}
//专门算阶乘的方法
public static int Factorial(int n) {
//设置程序递归的出口，否则会出现内存溢出错误
if (n == 1) {
return 1;
}
//54！，然后Factorial(n - 1)会调用自身，从而变成了43！，一直递归
return n * Factorial(n - 1);
}


Factorial是专门算阶乘的方法，自身调用自动，反复的递归，但是需要考虑程序的出口，也就是n=1的时候返回1，结束程序，不能使n=-1计算下去，否则会出现内存溢出报错。

码农公寓