【Java SE】----方法

1.方法定义

模块化组织代码，使代码达到复用  （方法名使用小驼峰）

public static 返回值类型 方法名（形式参数列表）{

方法体；

}

2.方法调用

• 在主函数内部被调用

//   两个数相加
    public static int add(int x,int y){
        return x+y;
    }
    public static void main(String[] args) {
        System.out.println(add(1,2));
    }

• 在其他函数内部被调用

 //求1！+2！+3！
    //求每个数的阶乘
    public static int fac(int x){
       int ret=1;
        for (int i = 1; i < x; i++) {
              ret*=i;
        }
        return ret;
    }
    //求每个数的和
    public static void main(String[] args) {
        int sum=0;
        for (int i = 1; i <=5 ; i++) {
            sum+=fac(i);
        }
        System.out.println(sum);
    }

注意：

1.函数名字和函数参数应该对应（从个数到类型），返回值可有可无，如果有返回值，注意返回值类型

2.定义方法的时候，方法代码不会执行，只有在调用的时候会执行

3.一个方法可以被多次调用

3.形参和实参关系

• 形参：方法在定义的时候需要借助的变量，用来保存方法在调用时传递过来的值
• 实参：是真正要传递的值
• 在Java中实参的值永远是拷贝到形参中，形参与实参本质上是两个实体，对形参的修改不会影响实参
• 例如：交换两个整型变量

 //交换两个整形变量
    public static void swap(int []array){
        int tmp=array[0];
        array[0]=array[1];
        array[1]=tmp;
    }
    public static void main(String[] args) {
        int[]arr={10,20};
        System.out.println("交换前："+arr[0]+" "+arr[1]);
        swap(arr);
        System.out.println("交换后："+arr[0]+" "+arr[1]);
    }

4.方法重载 

• 定义：方法名相同，参数列表不同（数据类型，个数，顺序），返回值无要求

    //求2个数相加
    public static int add(int x,int y){
        return x+y;
    }
    //求3个数相加
    public static int add(int x,int y,int z){
        return x+y+z;
    }
    //求2个double数
    public static double add(double x,double y){
        return x+y;
    }

• 优点：不需要过多的方法名，降低成本
• 构造方法算可以发生重载嘛？（可以，因为方法名相同，参数列表不同）

 5.方法递归

• 递归思想：把大问题分解成较小的问题去解决
• 注意：方法执行过程中调用本身，需要有终止条件,否则会产生栈溢出错误
• 每次递归的时候，这个函数只执行一部分，就去执行另一部分
• 递和归的次数是一样的
• 递的时候开辟栈空间，会因为方法没有执行完一直放在那，继续执行另一部分，遇到return才会回收
• 应用：

1. 求斐波那契数列  （1  1    2   3   5   8...)

//求斐波那契数列
    public static int fib(int n){
        if (n==1||n==2){
            return 1;
        }
        return fib(n-1)+fib(n-2);
    }
    public static void main(String[] args) {
        System.out.println(fib(5));
    }

  2.求5的阶乘

//求5的阶乘
    public static int fac(int n){
        if (n==1){
            return 1;
        }
        int tmp=n*fib(n-1);
        return tmp;
    }

   3.按顺序打印每一位  eg:1234

 //按顺序打印每一位
    public static void print(int x){
        if (x<10){
            System.out.println(x);
        }else {
            //先得到被除数
            print(x/10);
            System.out.println(x%10);
        }
    }

    4.求打印的每一位和

 //求打印每一位和
    public static int sum(int n){
        //如果只打印1位
        if (n<10){
            return n;
        }
        int tmp=n%10+sum(n/10);
        return tmp;
    }
    //按顺序打印每一位
    public static void print(int x){
        if (x<10){
            System.out.println(x);
        }else {
            //先得到被除数
            print(x/10);
            System.out.println(x%10);
        }
    }