Java的学习之路（Chp4 函数）

原创已于 2023-05-09 15:48:23 修改 · 264 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

于 2023-05-09 15:45:45 首次发布

Java学习之路专栏收录该内容

4 篇文章

订阅专栏

本文详细介绍了Java中的函数使用，包括函数的三要素（返回值、函数名、参数表），如何定义和调用函数，以及函数的返回值和流程控制。特别讨论了return语句的功能，函数的参数传递（实参与形参的区别），并展示了函数嵌套调用和递归调用的示例。此外，强调了函数在减少代码冗余、提高可维护性和灵活性方面的作用，并通过验证哥德巴赫猜想的程序来说明自顶向下逐步求精的设计方法。

Chp4 函数

1 函数的基本使用

1.1函数的三要素

对于函数而言，最重要的部分就是函数的三要素：返回值、函数名、参数表。

在Java中，函数也成为方法。

1.2函数的定义

        //1
public class TestFunction{
        //2
        public static void main(String args[]){
                //3
        }
        //4
}

对于上边的四个位置，只有//2和//4两个位置能够定义函数。定义了函数可以在主函数中调用。不论这个函数是定义在主函数之前还是定义在主函数之后，都能够调用，在定义的顺序方面没有要求。

在Java中定义一个函数，首先可以写两个单词：public static，加上这两个修饰符是为了能在主函数中正常调用。在public static之后就是函数的三要素。

假如要写一个add函数，该函数接受两个int类型作为参数，并且返回两个参数的和：

public static int add(int a,int b)

第一个int为返回值类型，表示add函数返回一个int值。add是函数名，圆括号内是参数表。

在函数参数表中定义的参数叫形参，形参作用的范围就是函数的内部。

如果调用一个函数时不需要参数，则参数表为空。

如果要写一个函数，用来表示当前是几点。这个函数不需要任何参数：

public static int getCurrentHour()

定义完函数之后，在函数后面紧跟一个代码块，花括号中写上函数要执行的内容。完整的add函数如下：

public static int add(int a,int b){
    int c = a + b;
    return c;
}

return语句除了表示函数返回值之外，同样可以表示函数的流程跳转。

1.3函数的调用

在调用函数的时候，为函数指定的参数，叫实参。在函数调用的过程中，会把实参的值传递给形参。

完整的add函数代码如下：

public class TestFunction {
    public static void main(String[] args) {
        int m = 10,n = 20;
        int result = add(m,n);
        System.out.println(result);
        add(30,40);
    }
    public static int add(int a,int b){
        int c = a + b;
        return c;
    }
}

运行结果如下：

由于第二次调用add函数时，没有保存其返回值，也没有把它输出。

1.3.1用return语句返回值

return语句表示返回一个值。在函数的定义中，如果给出了返回值类型，则必须要返回一个相应类型的值。

例如：

public static int m(){
    System.out.println("m()");
}

这个函数的返回值为int类型，表明这个函数不必须要返回一个整数值。如果在这个函数中没有return语句，则编译会出错。编译提示如下：

编译器提示，在代码这种缺少返回语句。

如果与函数定义中的返回值类型不同，也有可能出错。

例如，在m方法中如果返回一个double类型的值，代码如下：

public static int m(){
    System.out.println("m()");
    return 1.5;
}

编译提示如下：

编译器提示，可能损失精度。

1.3.2流程跳转以及void

public class TestFunction{
    public static void main(String args[])        //主函数，程序的入口
        System.out.println("Line 3");             //输出Line3
        int m = 10,n = 20;
        int result = add(m,n);                    //调用add函数，程序从第5行跳转到第11行
        System.out.println(result);
        System.out.println("Line 7");
        add(10,20);
        System.out.println("Line 9")
}
    public static int add(int a,int b){
        System.out.println("Line 12");            //输出Line12
        int c = a + b;
        System.out.println("Line 14");            //输出Line14
        rerturn c;                                //程序返回
    }    
}

因为void函数不返回值，所以在void函数中可以不包含return语句。

import java.util.Scanner;
public class TestVoid {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Input a number:");
        int a = sc.nextInt();
        printHelloWorld(a);
    }

    public static void printHelloWorld(int n){
        if(n > 10) return;
        for (int i = 0;i < n;i++){
            System.out.println("Hello World");
        }
    }
}

执行结果如下：

2实参和形参

public class TestParameter {
    public static void main(String[] args) {
        int a =10;
        changeInt(a);
        System.out.println(a);
    }
    public static void changeInt(int n){
        n++;
    }
}

3函数的嵌套调用

public class TestNestedCall {
    public static void main(String[] args) {
        System.out.println("main1");
        ma();
        System.out.println("main2");
    }
    public static void ma(){
        System.out.println("ma1");
        mb();
        System.out.println("ma2");
    }
    public static void mb(){
        System.out.println("mb1");
        System.out.println("mb2");
    }
}

执行结果如下：

4函数的递归调用

函数自身调用自身的情况，称为函数的递归调用。

例：计算一个整数的阶乘，代码如下：

import java.util.Scanner;
public class TestFactorial {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数n:");
        int n = sc.nextInt();
        int a = factorial(n);
        System.out.println(n + "!=" + a);
    }
    public static int factorial(int n) {
        if (n == 1) return 1;
        int result = factorial(n - 1);
        return n * result;
    }
}

执行结果如下：

如果需要写递归的话，要注意一下几个问题：

1）研究出一个推导公式，公式与参数有关，最好能用（n-1）调用的结果来计算调用n的结果。

2）要写出递归的收敛条件，避免无终止运行。

5.函数的作用

public class TestSeperator {
    public static void main(String[] args) {
        System.out.println("HelloWorld");
        //打印分隔符----------------------
        for (int i = 0; i < 20; i++) {
            System.out.print("-");
        }
        System.out.println();
        System.out.println("你好，世界");
        //打印分隔符----------------------
        for (int i = 0; i < 20; i++) {;
            System.out.print("-");
        }
        System.out.println();
        System.out.println("Hello Welt");
    }
}

执行结果如下：

由于上述代码需要输出三行分隔符，所以需要有三个一模一样的打印语句。因此可以写一个函数：printSeperator（），专门用来打印分隔符，修改后的代码如下：

public class TestSeperator {
    public static void main(String[] args) {
        System.out.println("HelloWorld");
        printSeperator();
        System.out.println("你好，世界");
        printSeperator();
        System.out.println("Bonjour tout le monde");
        printSeperator();
        System.out.println("Hallo Welt");
    }
    public static void printSeperator() {
        for (int i = 0; i < 20; i++) {
            System.out.print("-");
        }
        System.out.println();
    }
}

这是函数的第一个作用：减少冗余代码。

第二个作用试试让代码更加便于维护，提高代码的可维护性。

如果要把-改成+，只需要对函数进行更改就完成工作：

 public static void printSeperator() {
        for (int i = 0; i < 20; i++) {
            System.out.print("-");
        }
        System.out.println();
    }

第三个功能：使程序更加灵活

如果要第一个分隔符长度为20，第二个为25，第三个为30，只需要对这个函数传入不同的参数进行三次调用即可：

public static void main(String[] args) {
        System.out.println("HelloWorld");
        printSeperator(20);
        System.out.println("你好，世界");
        printSeperator(25);
        System.out.println("Bonjour tout le monde");
        printSeperator(30);
        System.out.println("Hallo Welt");
    }

6自顶向下逐步求精

例如验证哥德巴赫猜想：任何一个大于6的偶数，都能分解成两个质数的和。

要求：输入一个整数，输出这个数能被分解成哪两个质数的和。

例如：输入14

14=3+1

14=7+7

首先应该设计这个程序的大体思路，基本思路如下：

1.读入一个整数

2.把这个整数拆成两个数a、b的和

3.判断a是否为质数

4.判断b是否为质数

5.如果3，4两个判断为真，则输出a和b

6.如果这个整数还能拆分，则回到2否则程序退出。

循环(把整数n拆成两个整数a和b）{

判断a是否是质数

判断b是否是质数

如果a、b都是质数，则输出a和b

}

代码如下：

import java.util.Scanner;
public class TestGoldBach {
    public static void main(String[] args) {
        //读入整数
        System.out.println("请输入一个整数");
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();

        for (int i = 1;i <= n/2;i++){
            int a = i;
            int b = n - i;
            if(isPrime(a) && isPrime(b)){
                System.out.println(n + "=" + a + "+" + b);
            }
        }
    }

    public static boolean isPrime(int a){
        for (int i = 2;i <= a-1;i++){
            if (a % i == 0)return false;
        }
        return true;
    }
}

执行结果如图：