JAVA函数，运行原理，重载，递归等

JAVA基础——函数

1.函数的概念

​ 什么是函数

​ 函数的定义就是具有一段独立功能的代码，减少代码冗余，提高程序的利用率和效率。

​ 我们应该如何去定义函数？

• 需要一个封闭的空间，将这段代码进行封装 ，用一对大括号
• 需要对每一个封闭空间进行命名，函数名
• 函数所需要的一些原始数据
• 函数所产生的一些结果数据

函数的语法格式

修饰符 函数类型 返回值类型 函数名(数据类型 数据1,数据类型 数据2,...){
		独立功能的代码片段;
		return 函数的计算结果;
}

• 修饰符：函数的访问权限，public private 默认 protected
• 函数类型：函数的分类，本地函数native，静态函数static，同步函数
• 返回值类型：指的是函数计算结果的数据类型，如果函数没有返回值，则为void
• 函数名：就是函数的名称
• 参数列表：指的是外界向函数传入的数据（实际参数），由这些参数变量进行接收（形式参数）
• 函数体：具有独立功能的代码片段
• return：仅仅表示函数结束！如果函数有返回值，则return后跟返回值；如果函数没有返回值，则return可以不写，但是return是存在的（隐藏的，在最后一行）

根据形参和返回值来看，函数有如下几个分类

• 有参数有返回值

求三个数字当中的最大值

public class Test{
    public static void main(String[] args){
        int max = getMax(1,2,3);
        System.out.println(max);
    }
   //修饰符 函数类型 返回值类型 函数名（形参）
    public static int getMax(int a,int b,int c){
        /*if(a >= b && a >= c){
            return a;
        }else if(b >= a && b >= c){
            return b;
        }else{
            return c;
        }*/
        if(a >= b && a >= c){
            return a;
        }
        if(b >= a && b >= c){
            return b;
        }
        if(c >= a && c >= b){
            return c;
        }
        return -1;//没有此处返回int类型的特殊值会报错
    }
}

• 有参数没返回值

将三个字符串反转，并拼接打印

public class Test{
    public static void main(String[] args){
        print("123","456","789");
    }
    //123 456 789 =? 321654987
    public static void print(String s1,String s2,String s3){
        System.out.println(reverse(s1) + reverse(s2) + reverse(s3));
    }
    public static String reverse(String s){
        String res = "";
        for(int i = s.length()- 1; i >= 0;i--){
            res += s.charAt(i);
        }
        return res;
    }
}

• 没参数有返回值

• 没参数没返回值

总结定义函数时需要考虑的有那些？

• 函数的运行有哪些未知的参数
• 函数的运行结果有那些
• 明确参数和结果
• 明确内容和返回
• 函数到底要实现什么功能？尽量将独立且功能重复性较高的代码片段提取出来

2.函数的运行原理

​ 函数的运行是基于栈运行的

​ 栈：是一种先进后出的容器，我们这里面所说的栈是指JVM虚拟机中的栈内存空间

​ 每一个函数，叫做栈帧，栈帧中有的内容有函数的定义，参数列表，函数的执行内容代码

​ 每一个函数要运行，就相当于这个栈帧进入到栈内存-入栈

​ 如果一个函数即将结束，将这个栈帧从栈顶移除-出栈

​ 如果栈内存中有多个栈帧，运行的是最上面的栈帧，底下的栈帧暂停运行，直到该栈帧为栈顶元素

​ 比如：主函数先进栈，开始逐行运行，如果执行到第n行，调用另外一个函数A,则主函数在第n行暂停运行，将另一个函数A的栈帧入栈，再继续逐行运行，直到函数A的内容执行完毕，函数A出栈，主函数继续执行，以此类推。

3.函数的重载

​ 同一个类中可以出现多个同名函数，这个现象就叫做函数的重载（overload）

​ 如何区分同名函数是否是重载关系？前提必须是重名，和返回值类型无关（返回值类型只和函数的计算功能相关)，和权限也没有关系，和形式参数的名称也无关。只和形式参数的数据类型有关（数量，排列组合）

public static void show(int a;float b;char c){}

​ 下列哪些是该函数的重载：

• void show (int x,float y,char z)：不算重载，数据类型都是int float char
• void show(float b,int a,char c)：算重载，float int char 和 int float char排列顺序不一样
• void show(int a,int b,int c):算重载，顺序不一样 int int int
• double show():算重载，参数不一样，与返回值类型无关

寻找重载函数的流程

1. 看是否有确切的参数定义匹配：int int 找int int
2. 看是否有可兼容的参数定义匹配：int int 找double double或 int double 或double int
3. 如果可兼容的参数定义匹配较多，会报错 ——引用不明确

4.函数的递归

​ 函数的递归就是指函数自身调用自身。

• 但凡迭代可以解决的问题，递归都可以解决；递归能解决的问题，迭代不一定能解决

• 从内存的角度而言，函数如果过多的自我调用，势必会对内存占用过多

• 通常来讲，同样的问题用递归写要比迭代写代码量较少

  写递归时，一定要先去确定递归结束条件——递归边界

  什么情况下可以使用递归？迭代的，数学归纳法问题

  public class Test{
      public static void main(String[] args){
          /*show();//无限递归*/
          test(3);
      }
      public static void test(int n){
          System.out.println(n);
          if ( n == 1){
              return;
          }else{
              test(n - 1);
          }
      }
    /*  public static void show(){
          System.out.println("Hello");
          show();
      }*/
  }
  

  用递归实现1~100求和

  public class Test{
      public static void main(String[] args){        
          System.out.println(f(100));
          System.out.println(f(1000000));//StackOverflowError 超出栈内存，异常
      }
      /*
      求1+2+3...+99+100
      设函数f(x) = 1 + 2 + 3+...+ x-3 + x-2 + x-1 + x
      f(3)=1 + 2 + 3
      f(2)=1 + 2
      f(3)=f(2) + 3
      =>
              1,x=1
      f(x) = 
              f(x-1) + x,x > 1
      f(x) = f(x-1) + x
      f(100)=f(99) + 100
      f(99)=f(98 )+ 99
      ...
      f(3)=f(2) + 3
      f(2)=f(1) + 2
      f(1)=1 递归的边界
      */
      public static int f(int x){     
          if (x == 1){
              return 1;
          }else{
              return f(x - 1) + x;
          }
      }
  }
  

  打印p<=31的梅森素数

  public class Test{
      public static void main(String[] args){
          for(int p = 2;p <= 31;p++){
              int num = (int)Math.pow(2,p)- 1;
              if (isSuShu(num)){
                  System.out.println(num);
              }
          }
      }
      public static boolean isSuShu(int num){
          for(int i = 2;i <= num / 2;i++){
              if(num % i==0){
                  return false;
              }
          }
          return true;
      }
  
  }  
     public static boolean isSuShu(int num){
          for(int i = 2;i <= num / 2;i++){
              if(num % i==0){
                  return false;
              }
          }
          return true;
      }
  
  }