方法

JAVA方法

方法：方法其实就是若干语句的功能集合。

参数（原料）：就是进入方法的数据。

返回值（产出物）：就是从方法中出来的数据。

----------使用方法的注意事项：

(1)方法应该定义在类当中，但是不能在方法中再定义方法，不能嵌套。

(2)方法定义的前后顺序无所谓。

(3)方法定义之后不会执行，如果希望执行，一定要调用。(单独调用，打印调用，赋值调用)

(4)如果方法有返回值，那么必须写上"return 返回值 ;"，不能不写。

(5)return后面的返回值数据，必须和方法的返回值类型对应起来。

(6)对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。

(7)对于void方法当中最后一行的return可以省略不写。

(8)一个方法当中可以有多个return语句，但是必须保证同时只有一个会被执行，两个return不能连写。

一、定义格式：

修饰符 返回值类型 方法名称（参数类型 参数名称，...）{
    方法体;
    return 返回值;
}

修饰符：现阶段的固定写法，public static

返回值类型：也就是方法最终产生的数据结果是什么类型

方法名称：方法的名字，规则和变量一样

参数类型：进入方法的数据是什么类型

参数名称：进入方法的数据对应的变量名称

Ps：参数如果有多个，使用逗号进行分割

方法体：方法需要做的事情，若干行代码

return：两个作用，第一停止当前方法，第二将后面的结果数据返回值还给调用处

返回值：也就是方法执行后最终产生的数据结果

注意：return后面的“返回值”，必须和方法名称前面的“返回值类型”保持对应。

二、调用格式：

方法的三种调用格式：

(1)单独调用：方法名称(参数);

(2)打印调用：System.out.println(方法名称(参数));

(3)赋值调用：数据类型 变量名称 = 方法名称(参数);

注意：返回值类型固定写为void，这种方法只能单独调用，不能进行打印调用或者赋值调用。

例如：定义一个两个int数字相加的方法。

三要素：

(1)返回值类型：int

(2)方法名称：sum

(3)参数列表：int a, int b

package Test;

public class main {
    public static void main(String[] args) {
        //单独调用
        sum(10,20);
        System.out.println("---------------------");

        //打印调用
        System.out.println(sum(10,20));
        System.out.println("---------------------");

        //赋值调用
        int number=sum(15,25);
        System.out.println("变量的值："+number);
    }
    public static int sum(int a,int b){
        System.out.println("方法执行！");
        int result=a+b;
        return result;
    }
}

方法调用流程图解

三、对比有参数和无参数

有参数：小括号当中有内容，当一个方法需要一些数据条件，才能完成任务的时候，就是有参数。

例如：两个数字相加，必须知道两个数字各自是多少，才能相加。

无参数：小括号当中留空。一个方法不需要任何数据条件，自己就能独立完成任务，就是无参数。

例如：定义一个方法，打印固定10次Helloworld。

package Test;

public class main {
    public static void main(String[] args) {
        method1(10,20);
        System.out.println("------------------------------");
        method2();
    }
    //有参数
    //两个数字相乘，做乘法，必须知道两个数字各自是多少，否则无法进行计算
    public static void method1(int a,int b){
        int result=a*b;
        System.out.println("结果是："+result);
    }

    //无参数
    //例如打印输出固定10次文本字符串
    public static void method2(){
        for(int i=0;i<10;i++){
            System.out.println("Hello world!"+i);
        }
    }
}

四、有返回值和无返回值

1.有返回值

例如：定义一个方法，用来【求出】两个数字之和。（算完之后告诉结果）

package Test;

public class main {
    //调用之后把结果赋值给num变量
    public static void main(String[] args) {
        int num=getSum(10,20);
        System.out.println("返回值是："+num);
    }
    //这是一个方法，负责两个数字相加
    //有返回值int，调用则告诉结果
    public static int getSum(int a,int b){
        int result=a+b;
        return result;
    }
}

2.无返回值

例如：定义一个方法，用来【打印】两个数字之和。（算完之后负责显示结果，不用告诉）

package Test;

public class main {
    public static void main(String[] args) {
        printSum(100,200);
    }
    //这是一个方法，负责两个数字相加
    //没有返回值，自己进行打印输出
    public static void printSum(int a,int b){
        int result=a+b;
        System.out.println("结果是："+result);
    }
}

注意：

（1）对于有返回值的方法，可以使用单独调用，打印调用或者赋值调用。

（2）但是对于无返回值的方法，只能使用单独调用，不能使用打印调用或者赋值调用。

（3）对于void没有返回值的方法，只能单独调用，不能打印或者赋值。

System.out.println(printSum(10,20));     //错误写法！！！
int num2=printSum(10,20);                //错误写法！！！

五、方法重载

方法的重载（OverLoad）：多个方法的名称一样，但是参数列表不一样。

好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能。

例如：

package Test;

public class main {
    public static void main(String[] args) {
        System.out.println(sum(10,20));
        System.out.println(sum(10,20,30));
        System.out.println(sum(10,20,30,40));
    }
    public static int sum(int a,int b){
        return a+b;
    }
    public static int sum(int a,int b,int c){
        return a+b+c;
    }
    public static int sum(int a,int b,int c,int d){
        return a+b+c+d;
    }
}

方法重载与下列因素相关：

1.参数个数不同

2.参数类型不同

package Test;

public class main {
    public static void main(String[] args) {
        System.out.println(sum(10,20));
    }
    public static int sum(int a,int b){
        return a+b;
    }
    public static int sum(double a,double b){java
        return (int)(a+b);
    }
}

3.参数的多类型顺序不同

package Test;

public class main {
    public static void main(String[] args) {
        System.out.println(sum(10,20));
    }
    public static int sum(int a,double b){
        return (int) (a+b);
    }
    public static int sum(int a,double b){java
        return (int) (a+b);
    }
}

方法重载与下列因素无关：

1.与参数名称无关

2.与方法的返回值类型无关

package Test;

public class main {
    public static void main(String[] args) {
        System.out.println(sum(10,20));
    }
    //错误写法！与参数的名称无关
     	public static int sum(int x,int y){
            return x+y;
        }
    }
	//错误写法！与方法的返回值类型无关
    public static double sum(int a,double b){java
        return a+b+0.0;
    }
}

六、递归

1.直接递归

直接递归即在方法体中调用方法本身。

例如：斐波那契数列（直接递归）

package Test;

public class main {
    public static void main(String[] args) {
        int x1=1;
        int sum=0;
        int n=7;
        for(int i=1;i<=n;i++){
            x1=func(i);
            sum=sum+x1;
        }
        System.out.println("sum="+sum);
    }
    public static int func(int x){
        if(x>2)
            return (func(x-1)+func(x-2));
        else
            return 1;
    }
}

2.间接递归

间接递归值函数中调用了其他函数，而该其他函数又调用了本函数。

例如：斐波那契数列（间接递归）

package Test;

public class main {
    public static void main(String[] args) {
        int x1=1;
        int sum=0;
        int n=7;
        for(int i=1;i<=n;i++){
            x1=func1(i);
            sum=sum+x1;
        }
        System.out.println("sum="+sum);
    }
    public static int func1(int a){
        int b;
        b=func2(a);
        return b;
    }
    public static int func2(int b){
        if(b>2)
            return (func1(b-1)+func1(b-2));
        else
            return 1;
    }
}