java调用云小蜜 java 云函数

方法的定义与使用

• 八、方法的定义与使用

• 8.1、方法的定义

• 基本定义方式
• 关于方法名与变量的定义命名要求：
• 定义一个无参无返回值的方法
• 定义一个有参数有返回值的方法
• 利用return结束方法调用

• 8.2、方法重载

• 方法重载的定义
• 定义一个加法处理的方法
• 观察一个程序代码

• 8.3、方法递归调用

• 实现一个1~100的累加

• 递归方式：
• 传统方式：
• 代码分析处理：
• 整体形式：

• 计算“1！+2！+3！+4！+5！+… … +90!”

本系列内容为阿里云大学 java学习路线里的内容

阿里云大学 java学习路线传送门.

八、方法的定义与使用

在程序之中很多情况下是可能需要重复执行一些代码的。在有一些书上也会把方法（method）称为函数（function）。需要主要一点，本次进行方法定义的时候有一个前提：方法在主类中定义，并且由主方法直接调用。

8.1、方法的定义

基本定义方式

本次方法是定义在主类之中并且由主方法直接调用的，所以方法的定义语法如下：

public static 返回值类型 方法名称([参数类型 变量,....]) {
	// 该方法要执行的代码
	[return [返回值] ;]
}

对于返回值而言就可以使用Java中定义的数据类型了（基本数据类型、引用数据类型），在方法之中可以进行返回数据的处理，如果要返回数据则可以使用return来描述，return所返回的数据类型与方法的返回值类型相同，如果不返回数据，则该方法可以使用void进行声明。

关于方法名与变量的定义命名要求：

• 方法名和变量名命名规则一致
• 在进行方法名称定义的时候要求第一个单词的字母小写，而后每个单词的首字母大写。
• 在进行变量名称定义的时候要求第一个单词的字母小写，而后每个单词的首字母大写。
• 一个方法基本不会太长

定义一个无参无返回值的方法

public class test {
    public static void main(String args[]) {
        printMessage();           // 执行方法调用
        printMessage();           // 执行方法调用
    }
    public static void printMessage(){         // 该方法包含了三行代码
        System.out.println("***************");
        System.out.println("***   test  ***");
        System.out.println("***************");

    }
}

Output：
***************
***   test  ***
***************
***************
***   test  ***
***************

方法本质,就是方便使用者调用，程序都是从主方法开始往下执行的。

定义一个有参数有返回值的方法

public class test {
    public static void main(String [] args){
        String result = get(20.0) ;
        System.out.println(result) ;
        System.out.println(get(1.0)) ;   //返回值可以直接输出
    }
    public static String get(double money){
        if(money >= 10.0){
            return "一份快餐，找零：" + (money - 10.0);
        }else{
            return "对不起，余额不足。请先充值!";
        }
    }
}

Output：
一份快餐，找零：10.0
对不起，余额不足。请先充值!

在进行方法定义的时候，如果方法的返回值类型为void，那么可以利用return来结束调用。

利用return结束方法调用

public class test {
    public static void main(String args[]) {
        get(3);
        System.out.println("------------");
        get(0);
        System.out.println("************");
        get(2);
    }
    public static void get(int count){
        if(count <= 0) return;
        for (int x = 1; x <= count; x++){
            System.out.println("给我点了：" + x +"赞！");
        }

    }
}

Output：
给我点了：1赞！
给我点了：2赞！
给我点了：3赞！
------------
************
给我点了：1赞！
给我点了：2赞！

如果从定义的语法来讲方法并不是一个难以理解的概念，就是一段可以被重复调用的代码而已，但是良好的方法设计是需要根据实际的开发经验慢慢累计的，但是请千万记住一点：在Java定义方法的时候一般都不要太长。

8.2、方法重载

方法重载的定义

当方法名称相同，参数的类型或个数不同的时候就称为方法重载。

定义一个加法处理的方法

那么下面先通过个程序来做一个简单的分析，现在要定义一个加法处理的方法，该方法可以接收两个int变量、三个int变量、三个double变量的加法处理。

public class test {
    public static void main(String [] args){
        System.out.println("加法执行结果："+sum(1,2));          //调用两个int参数的方法
        System.out.println("加法执行结果："+sum(10,20,30));          //调用三个int参数的方法
        System.out.println("加法执行结果："+sum(11.1,22.2,33.3));
    }

    public static int sum(int x,int y){
        return x + y;
    }
    public static int sum(int x,int y,int z){
        return x + y + z;
    }
    public static double sum(double x,double y,double z){
        return x + y + z;
    }
}

Output：
加法执行结果：3
加法执行结果：60
加法执行结果：66.6

根据传参和返回自动选择方法体,实现方法重载

• 方法重载与方法返回类型没有关系
• 但实际开发中,只要时方法重载,强烈建议其返回值类型相同

观察一个程序代码

public class test {
    public static void main(String [] args){
        System.out.println(1);
        System.out.println(1.1);
        System.out.println(true);
        System.out.println('A');
        System.out.println("Hello World");
    }
}

Output：
1
1.1
true
A
Hello World

现在可以发现，所有的输出操作支持有各种数据类型，所以System.out.println()本身就属于一个方法重载。

8.3、方法递归调用

方法的递归调用指的是一个方法自己调用自己的情况，利用递归调用可以解决一些重复且麻烦的问题。在进行方法递归调用的时候一般需要考虑如下几点问题：

• 一定要设置方法递归调用的结束条件；
• 每一次调用的过程之中一定要修改传递的参数条件。

实现一个1~100的累加

递归方式：

public class test {
    public static void main(String [] args){
        System.out.println(sum(100));
    }
    public static int sum(int num){
        if(num == 1){
            return 1;
        }
        return num + sum(num - 1);
    }
}

Output：
5050

传统方式：

public class test {
    public static void main(String [] args){
        int sum = 0;
        int x = 1;
        while(x<=100){
            sum += x;
            x++;
        }
        System.out.println(sum);
    }
}

Output：
5050

代码分析处理：

· 【第1次执行sum()，主方法执行】return 100 + sum(99)；
· 【第2次执行sum()，sum()递归调用】return 99 + sum(98)；
· … … … … … …
· 【第99次执行sum(),sum()递归调用】return 2 + sum(1);
· 【第100次执行sum(),sum()递归调用】return 1;

整体形式：

return 100 + 99 + 98 + … … … + 2 + 1；递归操作虽然可以简化的调用，但是在实际开发之中，编写的代码可能会很少出现有递归情况。大部分情况下考虑的都只是一些简单的处理逻辑。递归少去使用还有另外一个原因：如果处理不当则会造成内存有溢出。

计算“1！+2！+3！+4！+5！+… … +90!”

在进行阶乘计算的时候必须要考虑选择的数据类型，肯定不能够使用int或long，只能够使用double。

public class test {
    public static void main(String [] args){
        System.out.println(sum(90));
        System.out.println(fan(90));
    }
    public static double sum(int num){
        if(num == 1)
            return 1;
        return fan(num) + sum(num - 1);
    }
    public static double fan(int num){           // 执行累加
        if(num == 1){                // 执行累加
            return 1;
        }
        return num * fan(num - 1);          // 递归调用
    }
}

Output：
1.502411534554385E138
1.4857159644817607E138

实际上有一部分的递归都是可以通过循环来完成，但是如果使用递归要比使用循环结构看起来更加清晰一些。