JavaSE-5-方法的使用

1.方法的基本用法

1.1 什么是方法

方法是语句的集合，它们在一起执行一个功能。

• 方法是解决一类问题的步骤的有序组合
• 方法包含于类或对象中
• 方法在程序中被创建，在其他地方被引用

1.2 方法的优点

• 使程序变得更简短而清晰。
• 有利于程序维护。
• 可以提高程序开发的效率。
• 提高了代码的重用性

1.3 方法的定义

基本语法：

// 方法定义
public static 方法返回值 方法名称（[参数类型 形参 ...]){
 方法体代码;
 [return 返回值];
}
// 方法调用
返回值变量 = 方法名称(实参...);

方法包含以下几个部分：

• 修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
• 返回值类型 ：方法可能会有返回值，有些方法没有返回值，在这种情况下，返回值为void。
• 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
• 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
• 方法体：方法体包含具体的语句，定义该方法的功能。

1.4 方法调用执行的过程

• 定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行.
• 当方法被调用的时候, 会将实参赋值给形参.
• 参数传递完毕后, 就会执行到方法体代码.
• 当方法执行遇到 return 语句, 就执行完毕, 回到方法调用位置继续往下执行.
• 一个方法可以被多次调用.

2. 方法的重载

如果一个类的两个方法具有相同的名称，但是签名不等价，那么这个方法名就被称为重载了
代码示例：

    /*
    重载：如果一个类的两个方法具有相同的名称，但是签名不等价，那么这个方法名就被称为重载了。
    满足条件：在同一个类中
            1.方法名相同
            2.方法的参数不同(参数个数或者参数类型)
            3.方法的返回值类型不影响重载
     */
    public static int sum(int a,int b) {
        System.out.println("调用了整数的方法！");
        return a+b;
    }
    public static double sum(double a,double b) {
        System.out.println("调用了 sumDouble 的方法！");
        return a+b;
    }
    public static void main(String[] args) {
        int ret = sum(10,30);
        System.out.println(ret);

        double ret2 = sum(11.2,23.4);
        System.out.println(ret2);
    }

上面的代码的特点是：在用一个类中，有多个方法。

• 方法名相同
• 方法的参数不同(参数个数或者参数类型)
• 方法的返回值类型不影响重载

3. 方法的递归

3.1 递归的概念

一个方法在执行过程中调用自身, 就称为 “递归”.
递归的条件：

• 如果问题是递归的，那么一定要调用自己
• 这个方法一定要有趋于终止的条件，否则会栈溢出。

递归的思想就是大问题化小问题

3.2 递归的过程分析

代码示例1：

/*
    递归：一个方法在执行过程中调用自身, 就称为 "递归".
     */
    public static int fac1(int i ) {
        System.out.println("函数开始，i=" + i);
        if (i == 1) {
            System.out.println("函数结束，i=" + i +" ; " + "ret = 1");
            return 1;
        }
        int ret = i * fac1(i-1);
        System.out.println("函数结束，i=" + i +" ; " + "ret = " + ret);
        return ret;
    }
    public static void main(String[] args) {
        int i = 5;
        int ret = fac1(i);
        System.out.println("ret=" + ret);
    }
    结果显示：
    /*
    函数开始，i=5
    函数开始，i=4
    函数开始，i=3
    函数开始，i=2
    函数开始，i=1
    函数结束，i=1 ; ret = 1
    函数结束，i=2 ; ret = 2
    函数结束，i=3 ; ret = 6
    函数结束，i=4 ; ret = 24
    函数结束，i=5 ; ret = 120
    ret=120 */

代码示例2：

/*
    递归：一个方法在执行过程中调用自身, 就称为 "递归".
     */
    public static int fac(int i) {
        if (i == 1) {
            return 1;
        }
        return i * fac(i-1);
    }
    public static void main(String[] args) {
        System.out.println(fac(5));
    }

流程分析：
递归的流程是先“递”出去，直到找到那个终止条件，然后把最终的数据按照方法给“归”回来。
上述的代码还可以用下面的流程来理解：