方法

方法

方法是具有独立功能的代码块，当一个方法被定义后，可以根据需求多次重用

方法定义的语法：

返回值类型  方法名（参数列表）{
    ....
   方法体
    ....
}
返回值类型可以是java支持的任何类型，也可以是void

方法的定义和调用:

    public class Demo7 {
        public static void main(String[] args) {
            int[] nums= {1,2,3,4,5};
            //这是方法的调用
            int sum=add(nums);
            System.out.println("这组数的和是:"+sum);
            int[] num2= {6,7,8,9,10,11};
            int sum2=add(num2);
            System.out.println("这组数的和是:"+sum2);
        }
        //方法的定义
        public static int add(int[] nums) {
            int sum=0;
            for(int i=0;i<nums.length;i++) {
                sum+=nums[i];
            }
            return sum;
        }
    }

带用返回值的方法：

public class Demo9 {
    public static void main(String[] args) {
        int result=add(10,100);
        System.out.println("结果:"+result);
    }
    public static int add(int n1,int n2) {
        int sum=n1+n2;
        return sum;
    }
}

注意:如果一个方法没有返回值，在定义的时候返回值类型声明为void,在这样的方法中也可以使用return,方法在执行的过程中如果遇到return,那么结束方法调用。

例：

public static void main(String[] args) {
        printStar(0,5);
    }
    /**
     * 
     * @param r 矩形的行数
     * @param n 矩形的列数
     */
    public static void printStar(int r,int n) {
        if(r<=0) {
            //遇到return就结束方法的调用
            return;
        }
        if(n<=0) {
            return;
        }
        for(int i=1;i<=r;i++) {
            for(int j=1;j<=n;j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

在定义带有返回值的方法中要使用return关键定指定返回的数据，返回的数据的类型要和定义的类型要一致，在调用带有返回值的方法时可以把方法调用方法一个赋值表达式中来接收方法的返回结果。 在定义带有参数的方法中，可以定义多个参数，构成方法参数的参数列表，这时需要注意，即使这个方法有多个类型相同的参数也要分别说明每一个参数的数据类型。

方法的参数:

方法在定义的时候，声明的参数称为形式参数，形式参数只是规定了
参数的类型，方法在调用的时候传入的参数称实际参数，实际参数
才是具有实际值的，在调用的时候把实际参数的值传给形式参数，
这个过程也可以称为虚实结合。

/**
     * 
     * @param r 矩形的行数 形参
     * @param n 矩形的列数 形参
     */
    public static void printStar(int r,int n) {
        if(r<=0) {
            //遇到return就结束方法的调用
            return;
        }
        if(n<=0) {
            return;
        }
        for(int i=1;i<=r;i++) {
            for(int j=1;j<=n;j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

练习四则运算:

import java.util.Scanner;
public class Demo14 {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.println("请输入第一个数:");
        int num1=input.nextInt();
        System.out.println("请输入第二个数:");
        int num2=input.nextInt();
        System.out.println("请输入运算符:");
        String o=input.next();
        System.out.println("两个数的计算结果是:"+cal(num1,num2,o));
    }
    public static int cal(int n1,int n2,String operator) {
            int result=0;
            switch(operator) {
            case "+":
                result=n1+n2;
                break;
            case "-":
                result=n1-n2;
                break;
            case "*":
                result=n1*n2;
                break;
            case "/":
                if(n2==0) {
                    n1=1;
                }
                result=n1/n2;
                break;
            default:
                System.out.println("不支持这种类型的运算");
                break;
            }
            return result;
    }
}

方法的重载

同一个类中，具有不同的参数列表，但是这些方法具有不同的参数列表，这样的方法构成方法的重载。

参数列表不同是指：

1.参数列表的个数不同

这两个方法可以构成重载
    public static int sum(int[] arrs) {
        int result=0;
        for(int i=0;i<arrs.length;i++) {
            result+=arrs[i];
        }
        return result;
    }
    public static int sum(int n1,int n2) {
        return n1+n2;
    }

2.参数列表的数据类型不同
    //这两个方法可以构成重载
    public static int sum(int n1,int n2) {
        return n1+n2;
    }
    public static String sum(char c1,char c2) {
        return c1+c2+"";
    }

注意:如果只有返回值不同不能构成方法的重载

方法的递归

方法自己调用自己，形成方法的递归

递归的层次不能过深，或者必须有退出条件，这两种情况不满足就会造成栈溢出错误

Exception in thread "main" java.lang.StackOverflowError

案例：使用递归方法实现1到10这10数的累加和:

public class Demo16 {
    public static void main(String[] args) {
        int result=sum(10);
        System.out.println(result);
    }
    public static int sum(int n) {
        /*if(n==1) {
            return 1;
        }*/
        return n+sum(n-1);
    }
}

求一个数的阶乘:

public class Demo17 {
    public static void main(String[] args) {
        int r=jiecheng(5);
        System.out.println(r);
    }
    public static int jiecheng(int n) {
        if(n==1) {
            return 1;
        }
        return n*jiecheng(n-1);
    }
}

求斐波那契数列:

package com.fc.karen;
public class Demo18 {
    public static void main(String[] args) {
        for(int i=1;i<=8;i++) {
            System.out.println(fn(i));
        }   
    }
    public static int fn(int n) {
        if(n==1) {
            return 1;
        }
        if(n==2) {
            return 1;
        }
        return fn(n-1)+fn(n-2);
    }
}