Java 函数

函数（方法）

在java中，一般以叫函数为方法

一、引言

用现有的知识打印这几句话

需要重复出现的代码多，不够精简
方法的概念

• 概念：实现特定功能的一段代码，可反复使用。
• 方法调用：方法名(),没参数时候直接一个括号，有参数时候里面需要传入参数，后面看到所有的 “名字()” 类型的均为方法调用

用方法把上面for循环语句封装起来，这样调用函数时候就能减少一大串代码重复出现，增加了可读性和减少代码冗余。
Java是面向对象语言，一切皆为对象，而对象的运行就在方法中，像我们一直在main()函数里运行代码一样，都是在函数里面运行。

二、方法的参数

像我们需要写的public static void main(String[] args)括号里头的了就是参数了

• 实参：我们传入方法的参数为实参，

• 形参： 方法获取该参数并在方法里面进行调用为形参
  

注意：传入进入的参数类型和方法定义的参数类型是必须一致的，就像int形不能接收String类型，但也是满足数据类型的转型的

例如小转大是没问题的（下面的byte类型转为int型）

public class Demo01 {
    public static void main(String[] args) {
        byte b = 10;
        //传入进入的是byte型
        go(b);
    }
//这参数是int型
    private static void go(int b) {
        System.out.println(b);
    }
}

参数类型，我们还能传数组、类，一切的引用数据类型（除了八大数据类型，其他的都基本为引用数据类型）

2.1 多个参数

在方法里需要定义了多个形参，调用方法需要传入多个参数

• 1、参数的传入必须按照，若顺序掉乱了，会报错。
  
• 2、Java方法里没有默认参数，一定需要传入相对应的参数数量和参数类型，参数顺序不能乱

public class Demo01 {
    public static void main(String[] args) {
        int i =10;
    //一定需要传入和形参一样多的参数数目和相对应的参数类型
        go(i);     //报错
    }
	//下面这样设置一个默认参数会报错
    private static void go(int i, String str="你好") {
        System.out.println(i);
        System.out.println(str);
    }
}

三、返回值类型

return 返回值，是接收方法返回类型和结束该方法标志

在我们经常写的public static void main(Sring[] args)中的void是什么呢？如果void 改为int、double、String…呢？

• void: 代表该方法不需要返回值 可以没有return,或者用return来进行结束方法(return 后面不能加任何返回类型)
• int:代表该方法需要返回一个int类型，且一定要有return 后面加一个int类型数据
• String:代表该方法需要返回一个String类型，且一定要有return 后面加一个String类型数据
  … …
  … …
  也就是说，除了void可有可无return外，其他的返回值类型必须有return和其相对应的返回值类型

public class Demo01 {
    public static void main(String[] args) {
        int i =10;
        fun1();
        fun2();
        double d = fun3();
        System.out.println(fun4());
    }

    //这是void,不需要return,或者可以单写一个return代表结束
    private static void fun1() {
        System.out.println("你好，我是void");
        //return;
    }

    //int，必须return int
    private static int fun2() {
        byte b = 1;
        System.out.println("我是int");
        return 1;

//        return也是可以小类型转大类型的，下面return也可以
//        return b;
    }

    //double
    private static double fun3() {
        System.out.println("我是double");
        return 1.1;
    }

    //String
    private static String fun4() {
        System.out.println("我是String");
        return "你好啊";
    }
}

有return返回值的，我们也可以用一个容器来装下它，return的主要作用就是于此

通过方法运算，得到一个返回值并进行。

下面为两个数加法运算

public class Demo02 {
    public static void main(String[] args) {
        int i = 10;
        int a = 20;
        //用相对应的类型装载
        int sum = addition(i, a);
        System.out.println(sum);
        //也可以直接输出
        System.out.println(addition(i,a));
    }

    private static int addition(int i, int a) {
        return i + a;
    }
}

不确定数量的传参

像上面的加法，只能传两个数，但平时我们计算机是可以传入多个的

我们在不确定参数数量的情况下，也是可以设置参数的，前提是同一个参数类型

public int fun(int… ints)
里面的 ints 其实是一个数组，后续深入研究

public class Demo02 {
    public static void main(String[] args) {
        int sum1 = addition(1, 2, 3, 4, 5);
        int sum2 = addition(1, 23, 4, 5, 6, 8, 9, 50, 2);
        System.out.println(sum1);
        System.out.println(sum2);
    }
//确定类型不确定数量传参
    private static int addition(int... ints) {
        int sum = 0;
        for (int i = 0; i < ints.length; i++) {
            sum += ints[i];
        }
        return sum;
    }
}

结果：
15
108

四、方法的重载

一个方法的名字只能有一个吗？

下面介绍方法的重载，一个方法的多种用法

如果一个类中有多个具有相同名称但参数不同，与返回值无关的方法，则称为方法重载

• 1、上面的方法均能同时存在，调用时候，传入相对应的参数，编辑器会自动匹配到相对应的方法中。

public class Demo03 {
    //相同类型，不同数量
    public void fun (int a){}
    public void fun (int a, int b){};
    public void fun (int a, int b, int c){};
    
    //不同类型和不同顺序
    public void fun(String s, int a){};
    public void fun(int a, String s){};
    
}

• 2、方法重载与返回值类型无关

public class Demo04 {
    
    //参数相同，返回值类型不同，报错！！！
    public void fun(int a){}
    public int fun(int a){return a;}
}

结果：
报错！！！

很显然，如果我们调用上面的fun方法，编辑器将不知道我们是调用哪个方法，所以报错。

五、递归(了解)

什么是递归？

• 解决具有既定规律的问题时，在方法内部再次调用自身方法的一种编程方式。

何时使用递归？

• 当需要解决的问题可以拆分成若干个小问题，大小问题的解决方式相同，方法中自己调用自己。
• 使用循环解决的常规问题，都可以替换为递归解决。

如何正确使用递归？

• 设置有效的出口条件，可以让调用链上的每个方法都可以正确返回，避免无穷递归。

简洁的说，递归是方法在自身里面调用自己，但我们需要有个尽头（有个出口），不然会报错

public class Demo05 {
    public static void main(String[] args) {
        go();
    }

    private static void go() {
        System.out.println("hello world");
        go();
    }
}

结果：
hello world
hello world
hello world
hello world
... ...
... ...
报错，内存溢出

像上面例子，main函数调用go方法后，该方法输出完"hello world"后再调用自己，然后就是不断死循环了

当编辑器运算一段时间后，发现不对劲了，这个完全没有尽头，就会报错了。

5.1递归经典案例

• 用递归算阶乘

  前面用for循环算阶时候是比较麻烦的，递归就简洁多了

public class Factorial {
    public static void main(String[] args) {
    //算10的阶乘
        int sum = factor(10);
        System.out.println(sum);
    }

    private static int factor(int i) {
        if (i==1){
            return 1;
        }
        return i*factor(i-1);
    }
}

结果：
3628800

• 用递归算斐波那契数列（下面）

  0 1 1 2 3 5 8 13 21 34 55 …

  可以看到0+1 = 1，1+1 = 2， 2+3 = 5…后一个数等于前两个数相加

public class Fibonacci {
    public static void main(String[] args) {
        int fi = fibo(10);
        System.out.println(fi);
    }

    private static int fibo(int i) {
        if (i == 1){
            return 0;
        }else if(i == 2){
            return 1;
        }
        return fibo(i-1) + fibo(i-2);
    }
}

递归这两个案例可以自己代入数，在纸上按着逻辑运行自己写一遍，就会理解了。