函数

函数
1，函数栈
主函数的格式分析：
public static void main(String[] args){
}
public 主函数的权限，主函数的最大权限
static表明主函数是静态的函数
main 主函数的名称
String[] 表示的是一个字符串数组(数据类型)， args数据类型的名称
一个函数基本组成是由 返回值类型 函数名 参数列表 函数体 返回值 组成
计算的a的b次幂

public static void main(String[] args){
  int a=8;  //实参
  hanshu(a); //调用hanshu函数
}
public static int hanshu(int a){  int a 是一个形式参数
int sum=1;
for(int i=1;i<=b;i++){
sum*=a;
}
}

函数是基于栈运行的

以下是函数基于栈运行的图解

2，函数的重载。同一类中出现的同名函数，与权限返回值无关，只有和参数类型排列组合有关(主要参数类型的匹配问题)。重载的好处是可以扩展函数的功能(函数重名，参数类型不一样)。寻找适当函数的流程：
1，看是否有确切的参数定义 int a,int b int a int b
2，看是否有可兼容的参数定义 int a int b double a double b
3，如果可兼容的参数有多个，就会出现引用的不明确 int a int b int a double b double a int b
3,函数的递归调用
递归的体现就是函数自身调用函数自身
解决的问题就是1，但凡被迭代解决的问题递归也能解决
2，递归解决的问题迭代就不一定解决了
3，递归其实就是分治法的一种实现方式（一种实现思路）
分治法是一种算法思想，主要解决的问题就是将大问题进行拆解拆分求解，最终将小问题的解进行合并，其实分治法就是一种暴力破解法
递归：先递后归1，前进段:指的就是将问题从大化小
2，结束段：问题无法再化小，则处理当前问题
3，返回段：将小问题处理完毕之后向上返回
缺点：越往后运行越慢，但是代码比较简洁
用递归计算1-100的和
f(n)+1
f(100)=f(99)+1
f(100)=f(99)+1
f(100)=f(99)+1
.
.
.
f(3)=f(2)+1
f(2)=f(1)+1
f(1)=1 递归循环一定要先写语句结束，否则将一直执行下去
代码如下：

  class test1{
   public static void main(String[] args){ //时间复杂数是2^n
           System.out.print( f(100));
   } 
   public static int f(int n){
       if(n==1){
           return 1;
       }
       return f(n-1)+n;
   }                 

内存运行图解：

2，斐波那契数列求前20项
1 1 2 3 5 8…
f(n)=f(n-1)+f(n-2)
它的结束条件是n=1或者n=2
运行代码就是：

class test2{
  public static void main(String[] args){ //时间复杂数n*2^n
       for(int i=1;i<=20;i++){
       System.out.print(febo(i)) ;
       System.out.println() ;
       }      
  } 
  public static int febo(int n){
       if(n==1|n==2){
           return 1;
       }
       return febo(n-1)+febo(n-2);
  }
}
用迭代来做上题
class test2{
  public static void main(String[] args){
      febo(20);
  } 
  public static void febo(int n){
         int a=1;
         int b=1;
         System.out.print(a);
         System.out.println();
         System.out.print(b);
         System.out.println();
         int count=2;
         int c;
         while(true){
          c=a+b;
          System.out.print(c);
          System.out.println();
          count++;
          if(count==n){
              return; 
          }
          a=b;
          b=c;
         }   
  }
}

时间复杂数图

汉诺塔

我是按照三个盘子举的例子，编程思想就是从简单推理到复杂
代码如下：
/*
打印汉诺塔的运行轨迹
*/

class test3{
public static void main(String[] args){
      hannuota(3, "x", "y", "z");
}
public static void hannuota(int n,String begin,String mid,String end){
    if(n==1){
        System.out.println(begin+"->"+end);//begin和end不是固定不变的，随着运行轨迹不断变化
    }
    else {
        hannuota(n-1,begin,end,mid);//递归调用
        System.out.println(begin+"->"+end);
        hannuota(n-1,mid,begin,end);//递归调用
    }
}
}

3，函数的权限(指的就是函数的使用范围，分为内部和外部)

public:表明该数据成员，成员函数是对所有用户开放，所有用户都可以直接进行调用
private：表示除了自己的class之外，其他人都不能调用