函数基础
一个典型的函数定义包括以下部分：修饰符、返回类型、函数名字、由0个或多个形参组成的列表以及函数体。
如以下函数：
public class Main {
private static int solve(int a , int b) {
int res = a * b;
return res;
}
}
注意在创建函数的时候使用
private static int solve(int a , int b)
1.solve
函数的名字，规范命名就好；
2.int
表示该函数返回一个整型值，return结束solve函数并且返回一个res这个整型值；
大多数类型都能用作函数的返回类型。
一种特殊的返回类型是void，它表示函数不返回任何值，因此在没有特地去return的情况下，void函数基本可以无缝衔接到原函数中，用于查重；
3.private static
修饰符包括private、static等，它们属于类相关的概念，慢慢学。
4.(int a , int b)
先来讲一下调用；
public class Main {
private static int solve(int a , int b) {
int res = a * b;
return res;
}
public static void main(String[] args) {
int res = solve(5 , 6);
}
}
在主函数里的5和6是实参，分别对应solve函数里的a和b,这两个形参；
形参列表中的形参通常用逗号隔开，其中每个形参都是含有一个声明符的声明，即使两个形参的类型一样，也必须把两个类型都写出来：
实参是形参的初始值，第一个实参初始化第一个形参，第二个实参初始化第二个形参，依次类推。
而且形参和实参的类型和个数必须匹配。如以下
solve("HELLO" , "WORLD"); // 错误：实参类型不正确
solve(); // 错误：实参数量不足
solve(42, 10, 0); // 错误：实参数量过多
solve(' ' , ' '); // 正确：该实参能自动转换成int类型，' '的ASCII值为32，所以该操作等价于solve(32 , 32);
函数的形参列表可以为空，但是不能省略。
void solve()
变量的作用范围
暂时只使用静态成员变量和静态成员函数，非静态成员变量/函数及其区别慢慢学。
函数内定义的变量为局部变量，只能在函数内部使用。
定义在类中的变量为成员变量，可以在类的所有成员函数中调用。
当局部变量与全局变量重名时，会优先使用局部变量。
public class Main {
private static int x = 4;//成员变量，作用于整个Main
private static void f1() {
int x = 3;//无视成员变量，使用局部变量；
System.out.println(x);
}
private static void f2() {
System.out.println(x);
}
private static void f3() {
System.out.println(x + 1);
}
public static void main(String[] args) {
f1();//3
f2();//4
f3();//5
f2();//4
}
}
参数传递
1.值传递
八大基本数据类型（int , float......）和String类型等采用值传递。
将实参的初始值拷贝给形参。
此时，对形参的改动不会影响实参的初始值。
public class Main {
private static void f(int x) {
x = 5;
}
public static void main(String[] args) {
int x = 10;
f(x);
System.out.println(x);//依旧是10；
}
}
2.引用传递
除String以外的数据类型的对象，例如数组、StringBuilder等采用引用传递。
将实参的引用（地址）传给形参，通过引用找到变量的真正地址，然后对地址中的值修改。
所以此时对形参的修改会影响实参的初始值。
import java.util.Arrays;
public class Main {
private static void f1(int[] a) {
for (int i = 0, j = a.length - 1; i < j; i ++, j -- ) {
int t = a[i];
a[i] = a[j];
a[j] = t;
}
}
private static void f2(StringBuilder sb) {
sb.append("Hello World");
}
public static void main(String[] args) {
int[] a = {1, 2, 3, 4, 5};
f1(a);
System.out.println(Arrays.toString(a));//[5 , 4 , 3 , 2 , 1]
StringBuilder sb = new StringBuilder("");
f2(sb);
System.out.println(sb);//Hello World
}
}
返回
return语句终止当前正在执行的函数并将控制权返回到调用该函数的地方。
return语句有两种形式：
return;
return val;
1.void函数
没有返回值的return语句只能用在返回类型是void的函数中。
返回void的函数不要求非得有return语句，因为在这类函数的最后一句后面会隐式地执行return。
通常情况下，void函数如果想在它的中间位置提前退出，可以使用return语句。
return的这种用法有点类似于用break语句退出循环。
public class Main {
private static void swap(int[] a) { // 交换a[0]和a[1]
// 如果两个值相等，则不需要交换，直接退出
if (a[0] == a[1])
return;
// 如果程序执行到了这里，说明还需要继续完成某些功能
int tmp = a[0];
a[0] = a[1];
a[1] = tmp;
// 此处无须显示的return语句
}
public static void main(String[] args) {
int[] a = {3, 4};
swap(a);
System.out.printf("%d %d\n", a[0], a[1]);
}
}
除void之外,只要函数的返回类型不是void，则该函数内的每个分支都必须有return语句，且每条return语句都必须返回一个值。
return语句返回值的类型必须与函数的返回类型相同，或者能隐式地转换函数的返回类型。
函数重载
就是同一类中，两个或多个函数重名，但是参数列表不同，此时编译器会根据实参的类型选择最匹配的函数来执行。
import java.util.Scanner;
public class Main {
private static int max(int a, int b) {
System.out.print("int max：");
if (a > b) return a;
return b;
}
private static double max(double a, double b) {
System.out.print("double max：");
if (a > b) return a;
return b;
}
public static void main(String[] args) {
System.out.println(max(3, 4));
System.out.println(max(3.0, 4.0));
}
}
输出如下
int max:4
double max:4.0
函数递归
函数自己调用自己，主函数不可调用；
import java.util.Scanner;
public class Main {
private static int fib(int n) { // 求斐波那切数列第n项
if (n <= 2) return 1;
return fib(n - 1) + fib(n - 2);
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
System.out.println(fib(n));
}
}