方法（函数）

方法（函数）

一、课前问答

1、break和continue的区别

2、嵌套循环的执行流程

3、二进制有哪些运算？简单说明

二、方法和函数

都是指实现特定功能的代码，可以反复使用。

早期称为函数，例如C语言等。

后来出现了Java等面向对象的语言，将程序中的内容称为对象，而对象具备属性和方法。方法具体实现过程与函数一样。只是名称不同。

以下演示一段不规范的代码：

public class Demo01 {
    public static void main(String[] args) {
        System.out.println("床前明月光，");
        System.out.println("----------");
        System.out.println("疑是地上霜。");
        System.out.println("----------");
        System.out.println("举头望明月，");
        for (int i = 0; i < 10; i++) {
            System.out.print("-");
        }
        System.out.println();
        System.out.println("低头思故乡。");
        for (int i = 0; i < 10; i++) {
            System.out.print("-");
        }
        System.out.println();
    }
}

上面的代码存在冗余，可以定义方法来解决。

定义方法的语法：

public static void 方法名(){

// 方法的主体（功能代码）

}

public class Demo01 {
    public static void main(String[] args) {
        System.out.println("床前明月光，");
        printSign();
        System.out.println("疑是地上霜。");
        printSign();
        System.out.println("举头望明月，");
        printSign();
        System.out.println("低头思故乡。");
        printSign();
    }
​
    public static void printSign() {
        for (int i = 0; i < 10; i++) {
            System.out.print("-");
        }
        System.out.println();
    }
}

三、方法的参数

调用方法时，传入的数据叫做参数。

语法：

public static void 方法名称(形参){

}

调用：

方法名称(实参);

形参与实参：形参是形式上的参数，在方法定义时写在方法括号中的变量，在没有被调用时没有实际的值。实参是指方法在调用时传入的实际的值。

3.1 单个参数

public class Demo01 {
    public static void main(String[] args) {
        System.out.println("床前明月光，");
        int n = 6;
        printSign(n); // 实参
        System.out.println("疑是地上霜。");
        printSign(7);
        System.out.println("举头望明月，");
        printSign(8);
        System.out.println("低头思故乡。");
        printSign(9);
    }
​
    public static void printSign(int count) { // 形参
        for (int i = 0; i < count; i++) {
            System.out.print("-");
        }
        System.out.println();
    }
}

3.2 多个参数

public class Demo01 {
    public static void main(String[] args) {
        System.out.println("床前明月光，");
        int n = 6;
        printSign(n, "#"); // 实参
        System.out.println("疑是地上霜。");
        printSign(7, "-");
        System.out.println("举头望明月，");
        printSign(8, "~");
        System.out.println("低头思故乡。");
        printSign(9, "_");
    }
​
    public static void printSign(int count, String sign) { // 形参
        for (int i = 0; i < count; i++) {
            System.out.print(sign);
        }
        System.out.println();
    }
}

注意：多个参数在使用时应该按照参数的类型对应的顺序传入。

四、方法的返回值

语法：

public static 返回值类型 方法名(参数列表){

// 内容

}

调用：

变量 = 方法名(实参);

注意：在方法定义了返回值类型时，必须要返回相应的值，不能有条件返回，也不能多次返回。当执行了返回后，方法调用结束。

public class Demo05 {
    public static void main(String[] args) {
        // 调用
        int s = he(3, 5);
        System.out.println(s);
    }
​
    private static int he(int m, int n) {
        int sum = m + n;
        return sum;
    }
}

return的两种用法：

一是返回相应类型的值。

二是当方法没有返回值时，直接结束方法，使用return;

public class Demo06 {
    public static void main(String[] args) {
        // 调用
        m1();
    }
​
    private static void m1() {
        for (int i = 1; i < 20; i++) {
            for (int j = 1; j < 33; j++) {
                int k = 100 - i - j;
                if(i * 5 + j * 3 + k / 3 == 100 && k % 3 == 0) {
                    System.out.println("公鸡"+i+",母鸡"+j+"，小鸡" + k);
                    return;
                }
            }
        }
    }
}

求阶乘之和。

public class Demo07 {
    // 求1!+2!+3!+4!+...+10!
    // 10! = 1x2x3x4x5x6x7x8x9x10
    /**
     * 求和
     */
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 10; i++) {
            sum += m1(i);
        }
        System.out.println("和为" + sum);
    }
​
    /**
     * 求阶乘
     * @param i 传入数字
     * @return
     */
    private static int m1(int i) {
        int s = 1;
        for (int j = 1; j <= i; j++) {
            s *= j;
        }
        return s;
    }
}

求100以内所有质数之和。

public class Demo08 {
    /**
     * 求100以内所有的质数之和
     */
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 2; i <= 100; i++) {
            if(m1(i)) {
                System.out.println(i);
                sum += i;
            }
        }
        System.out.println("和为" + sum);
    }
​
    /**
     * 判断一个数字是否质数
     * @param i 传入数字
     * @return
     */
    private static boolean m1(int i) {
        for (int j = 2; j < i; j++) {
            if(i % j == 0) {
                return false;
            }
        }
        return true;
    }
}

注意：Java中只能有一个返回值，切该返回值应该符合返回值类型（包括自动类型转换）。

求1000以内所有的完数之和

public class Demo09 {
    /**
     * 求1000以内所有的完数之和
     */
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 1000; i++) {
            if(m1(i)) {
                System.out.println(i);
                sum += i;
            }
        }
        System.out.println("和为" + sum);
    }
​
    /**
     * 判断一个数字是否完数
     * @param i 传入数字
     * @return
     */
    private static boolean m1(int i) {
        int sum = 0;
        for (int j = 1; j < i; j++) {
            if(i % j == 0) {
                sum += j;
            }
        }
        if(sum == i) {
            return true;
        }else {
            return false;
        }
    }
}

五、方法的多级调用

一个方法中调用另一个方法，称为多级调用。

public class Demo10 {
    public static void main(String[] args) {
        m1();
    }
​
​
    public static void m1() {
        System.out.println("m1===start");
        m2();
        System.out.println("m1===end");
    }
    
    public static void m2() {
        System.out.println("m2===start");
        System.out.println("m2===end");
    }
}

如果将上面的m2()调用部分换成m1()。则会出现无穷递归，最终结果会报错：Exception in thread "main" java.lang.StackOverflowError

六、递归

递归就是在方法中自己调用自己，需要使用递归。

递归使用时需要注意，一定要有一个出口，在调用链调用时能够正确停止，避免无穷递归。

使用递归实现斐波拉契数列数列：

// 先使用循环
public class Demo11 {
    public static void main(String[] args) {
        for (int i = 1; i <= 50; i++) {
            System.out.println(m1(i));
        }
    }
​
    /**
     * 斐波拉契数列
     * 1 1 2 3 5 8 13...
     * 前两项为1，后面每一项为前两项之和
     */
    public static long m1(int n) {
        if(n == 1 || n == 2) {
            return 1;
        }else {
            long a = 1;
            long b = 1;
            long c = 0;
            for (int i = 3; i <= n; i++) {
                c = a + b;
                a = b;
                b = c;
            }
            return c;
        }
    }
}

public class Demo12 {
    public static void main(String[] args) {
//      for (int i = 1; i <= 50; i++) {
//          System.out.println(i + "====" + f(i));
//      }
        f(5);
    }
​
    /**
     * 斐波拉契数列
     * 1 1 2 3 5 8 13...
     * 前两项为1，后面每一项为前两项之和
     * 
     */
    public static long f(int n) {
        if(n == 1 || n == 2) {
            return 1;
        }else {
            return f(n-1) + f(n-2);
        }
    }
}

注意：在上面的代码中，使用循环比递归效率要高，因为递归中创建了很多个方法栈。

求n的阶乘：

public class Demo13 {
    public static void main(String[] args) {
        System.out.println(f(5));
    }
​
    /**
     * 求n的阶乘
     */
    public static long f(int n) {
        if(n == 1) {
            return 1;
        }else {
            return n * f(n-1);
        }
    }
}