函数的栈、重载、递归调用

1.函数的格式

函数格式：访问权限  函数类型  返回值类型    函数名（参数列表）{

                                  函数体   

                                  return  返回值；

                   }

代码举例：

//判断素数
    public static boolean suShu(int number){
        boolean flag=true;
        //拆数字并反顺序组合
        for(int i=2;i<=number-1;i++){
            if(number%i==0){
                flag=false;
                break;
            }
        } 
        return flag;
    }
    //判断回文数
    public static int huiWenShu(int number){
        int mul=0;
        int temp=number;
        boolean flag=suShu(number);
        while(flag){
            mul=mul*10+number%10;
            number/=10;
            if(number==0){
                break;
            }
        }
        if(temp==mul){
            return temp;
        }else{
            return 0;
        }
    }

注意：有返回值的函数，参与运算、输出、赋值；无返回值的函数，仅仅调用，返回类型一定和返回值类型是可兼容的。

2.函数栈

2.1  栈的基本知识：先进后出，后出先进，一般把出栈叫做弹栈。下面用代码加图的方式更深的了解,如下：

2.2  所有的代码全写在主函数和代码切片封装调用的区别：

     2.2.1 所有的代码全写在主函数：代码的可读性差，进栈后占据不必要的空间，主函数冗余不方便查找错误

     2.2.2 代码切片封装调用：主函数进栈执行代码，执行到调用函数时，调用函数进栈（返回值或者打印）后，就弹栈了，栈中的代码少，运行速度快，这也是代码优化的体现。

3.函数的重载

3.1 注意：与权限没有关系，与返回值类型没有关系，与参数名没有关系，只与参数的排列组合有关系（注意参数类型的向下兼容问题）

     常见错误：寻找当前函数的流程  1.看是否有明确的参数定义  int+int  查看是否有（int，int）    2.看是否有可兼容的参数定义  int+int  查看是否有（double，double）3. 如果可兼容的参数定义有多个   int+int，查看的有（int，double）或者（double，int）此时报错，引用不明确。

3.2 代码举例：

class D1{
    public static void main(String []args){
      int a=3,b=4;
      double c=3.2,d=4.3;
      System.out.println(add(a,b));//add(int a,int b)
      System.out.println(add(a,c));//add(int a,double c)
      System.out.println(add(d,b));//add(double d,int b)
      System.out.println(add(c,d));//add(double c,double d)
    }
    public static int add(int a,int b){
        return a+b;
    }
    public static double add(int a,double c){
        return a+c;
    }
    public static double add(double d,int b){
        return d+b;
    }
    public static double add(double c,double d){
        return d+c;
    }
}
/*
以上的add就是函数重载
7
6.2
8.3
7.5
*/

4.函数的递归调用

4.1 递归的含义：分治法的一种实现方式，分治法是一种算法思想，分治法主要解决的问题是将大问题进行拆分，拆分成若干个小问题进行求解，最终将每个小问题的解进行合并。  分治法是一种暴力破解法（穷举），也是一种搜索最佳答案的算法

4.2 汉诺塔问题

4.2.1 图解

4.2.2 代码

class D1{
    public static void main(String[] args){
        //盘子的个数 出发 中间 目的
        hanno(3,"X","Y","Z");
    }                                     
    public static void hanno(int n,String begin,String mid,String end){
        if(n==1){
            System.out.println(begin+" -> "+end);
        }else{
            hanno(n-1,begin,end,mid);
            System.out.println(begin+" -> "+end);
            hanno(n-1,mid,begin,end);
        }
    }
}