方法重载overload

如果不使用方法重载，有相似功能的方法，就需要记很多的方法名，这样程序员会很累，而且代码不美观。
在java语言中，首先java编译器会通过方法名进行区分。但是在java语言中允许方法名相同的情况出现。如果方法名相同的情况下，编译器会通过方法的参数类型进行方法的区分。
那什么时候需要考虑使用方法重载呢？
在同一个类当中，如果“功能”1和“功能2” 他们的功能是相似的，那么可以考虑将他们的方法名一致，这样代码既美观又便于后期的代码编写（容易记忆，方便使用）.
注意：方法重载overload不能随便使用，如果两个功能压根不相干，不想死，根本没关系，此时两个方法使用重载机制的话，会导致编码更麻烦。无法进行功能的区分。
什么时候代码会发生方法重载呢？
条件1：在同一个类当中
条件2：方法名相同
条件3：参数列表不同
参数的个数不同算不同
参数的类型不同算不同
参数的顺序不同算不同

只要同时满足以上三个条件，那么我们可以认定方法和方法之间发生了重载机制。
注意：不管代码怎么写，最终一定能让java编译器很好的区分开这两个方法。
方法重载和方法的返回值类型无关。
方法重载和方法的修饰符列表无关。
在此之前我们使用的System.out.println();中的println是一个方法名，这个方法名是SUN公司的java团队写的。println()方法肯定时重载了。

代码包装

这样的代码，可以把System.out.println();替换成S.p.();，相当于把原有的SUN公司规定的代码进行了包装，下次再用就可以直接调用这个类名了。
注意：使用的时候，S.class文件要和你要调用的那个文件放在同一路径下。

public class S{
    //换行的方法
    public static void p(){
        System.out.println();
    }
    //输出byte
    public static void p(byte b){
        System.out.println(b);
    }
    //输出short
    public static void p(short s){
        System.out.println(s);
    }
    //输出int
    public static void p(int i){
        System.out.println(i);
    }
    //输出long
    public static void p(long l){
        System.out.println(l);
    }
    //输出float
    public static void p(float f){
        System.out.println(f);
    }
    //输出double
    public static void p(double d){
        System.out.println(d);
    }
    //输出boolean
    public static void p(boolean b){
        System.out.println(b);
    }
    //输出char
    public static void p(char c){
        System.out.println(c);
    }
    //输出String
    public static void p(String s){
        System.out.println(s);
    }
}

方法递归recursion

1、方法自己调用自己，这就是方法递归
2、当递归程序没有结束条件，一定会发生：栈内存溢出错误：stackoverflowerror。
所以递归必须要有结束条件。
JVM发生错误之后只有一个结果，就是退出JVM。

递归没有结束条件的时候会发生栈内存溢出错误.png

3、递归假设是有结束条件的，也有可能发生栈内存溢出错误。假设这个结束条件是对的，是合法的，递归有的时候也会出现栈内存溢出错误，因为有可能递归的太深了，栈内存不够了。因为一直在压栈。
4、在实际的开发中，不建议轻易的选择递归，能用for循环while循环代替的，尽量使用循环来做。因为循环的效率高，耗费的内存少。递归耗费的内存比较大，另外递归的使用不当，会导致JVM死掉。（但在极少数的情况下，不用递归，这个程序没办法实现。）
5、在实际的开发中，假设有一天你真正的遇到了：StackOverflowError，怎么解决？
首先第一步：先检查递归的结束条件对不对。如果递归结束条件不对，必须对条件进一步修改，直到正确为止。
第二步：假设递归条件没问题，这个时候需要手动调整JVM的栈内存初始化大小。可以将栈内存的空间调大点。（可以调整大一些）
第三步：调整了大小，如果运行时还是出现这个错误，没办法，只能继续扩大栈的内存大小。
怎么调整栈内存大小呢？
在dos命令窗口中，输入“java -X”可以找到一个-Xss<size>的命令，就是来更改栈内存大小的。例如：java -Xss xxxGB xx.java

使用循环计算1~n的和

public class Test{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入一个正整数n的值：");
        int n = s.nextInt();
        int retVaule = sum(n);
        System.out.println(retVaule);
    }
    //定义一个计算1~n的和的方法
    public static int sum(int n){
        int result = 0;
        for(int i = 1; i <= n; i++){
            result += i;
        }
        return result;
    }
}

使用递归计算1~n的和

public class Test{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入一个正整数n的值：");
        int n = s.nextInt();
        int retVaule = sum(n);
        System.out.println(retVaule);
    }
    //定义一个计算1~n的和的方法
    public static int sum(int n){
        if(n == 1){
            return 1;
        }
        //程序能执行到此处说明n不是1
        return n + sum(n-1);
    }
}

递归的内存图分析

以n为3为例

递归原理.png

public class Test{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入一个正整数n的值：");
        int n = s.nextInt();
        long retVaule = jieCheng(n);
        System.out.println(retVaule);
    }
  
    public static long jieCheng(int n){
        if(n == 1){
            return 1;
        }
        //程序能执行到此处说明n不是1
        return n * jieCheng(n-1);
    }
}