初识“方法”，步入编程领域 | 带你学《Java编程入门》之六

上一篇：带你学《Java编程入门》之五：“直线、分叉、圆圈”--程序逻辑之争
【本节目标】
本章主要讲的是方法的定义与使用，要求学完之后掌握方法的名称与变量的定义命名要求，学会方法的重载，知道并了解方法的递归调用。

6.1　方法的基本定义

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

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

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

• 在进行方法名称定义的时候要求第一个单词的字母小写，而后每个单词的首字母大写。
• 在进行变量名称定义的时候要求第一个单词的字母小写，而后每个单词的首字母大写。

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

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

图一 运行结果一

方法的本质就是方便使用者进行重复的调用，并且所有程序一定是通过主方法开始执行的。
范例：定义一个有参有返回值的方法

public class JavaDemo {
    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 "对不起，您的余额不足，请先充值，或者捡漏。" ;
        }
    }
}

图二 运行结果二

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

public class JavaDemo {
    public static void main(String args[]) {
        sale(3) ;
        sale(-3) ;
    }
    public static void sale(int money) {
        if (money <= 0) {    // 余额不足
            return ;    // 后续代码不执行了
        }
        for (int x = 1 ; x <= money ; x ++) {
            System.out.println("王健开笑，第" + x + "次") ;
        }
    }
}

图三 运行结果三

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

6.2　方法的重载

方法重载的定义：当方法名称相同，参数类型或个数不同的时候就称为方法重载。
那么先通过程序来做一个简单的分析，现在定义一个加法处理方法，该方法可以接收两个int变量、三个int变量、两个double变量的加法处理。
范例：采用方法重载进行定义

public class JavaDemo {
    public static void main(String args[]) {
        int resultA = sum(10,20) ;     // 调用两个int参数的方法
        int resultB = sum(10,20,30);    // 调用三个int参数的方法
        double resultC = sum(10.2,20.3) ;
        System.out.println("加法执行结果：" + resultA) ;
        System.out.println("加法执行结果：" + resultB) ;
        System.out.println("加法执行结果：" + resultC) ;
    }
    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) {
        return x + y ;
    }
}

图四 运行结果四

这个时候可以发现同一个方法名称但是可以根据调用时传递的不同参数的类型或个数实现不同方法体的调用，这样就实现了方法重载的定义。
注意：方法的重载与方法的返回值类型没有任何关系，它只跟参数有关系，但是在实际的开发中要把握一个基本的开发原则：只要是方法重载，强烈建议其返回值类型相同。
范例：观察一个程序代码

public class JavaDemo {
    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 !") ;
}
}

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

6.3　方法递归调用

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

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

范例：实现一个1~100的累加
使用while循环实现：

public class JavaDemo {
    public static void main(String args[]) {
        int sum = 0 ;
        int x = 1 ;
        while (x <= 100) {    // 循环的结束条件
            sum += x ;
            x ++ ;        // 修改每一次循环的变量
        }
        System.out.println(sum) ;  //执行结果：5050
    }
}

使用递归：

public class JavaDemo {
    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) ;    // 递归调用
    }
}

下面对此代码进行简单分析处理：

 【第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!”

public class JavaDemo {
    public static void main(String args[]) {
        System.out.println(sum (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) ;    // 递归调用
    }
}

图五 运行结果五

在进行阶乘计算的时候必须要考虑选择的数据类型，肯定不能够使用int，只能够使用double。
实际上有一部分递归是可以通过循环来完成的，但是如果使用递归要比使用循环结构看起来更加清晰一些。
想学习更多的Java的课程吗？从小白到大神，从入门到精通，更多精彩不容错过！免费为您提供更多的学习资源。
本内容视频来源于阿里云大学
更多Java入门编程文章查看此处