对相同代码块的提取和封装，并对其进行命名：函数名。通过函数名可是实现函数的调用
public staric:修饰符
int：返回值类型
add：函数名
（int a，int b）：函数的参数，形参
返回值类型：函数调用完成后，如果希望返回一个结果，那么在返回值类型处就写该结果，
对应的类型，在函数最后面可以通过return值；方式结果返回给函数调用者。
如果不需要拿到函数执行的如果，返回值类型处就写void，表示无返回值，在函数最后面不饿能写return，
或者只能写单独的一个return，表示程序执行到此结束。
函数的调用：通过函数名和参数值来进行调用
add（20，30）；
20，30叫做实参，按顺序传递给形参a和b
public static void printAny(String s) { //··带参数的函数··
//String s：形参，形式参数，作用就是规定传给函数的值是什么类型
//传给函数的值会赋值给形参s
System.out.print(s);
}
public static void main(String[] args) {
//mian函数，程序的入口
//通过名称和实参值调用函数:
printAny("AAA");//AAA:实参，在函数调用过程中会赋值给形参String s；相当于String s="AAA";
printA();
//System.out.println("AAA");
printB();
//System.out.println("BBB");
printA();
//System.out.println("AAA");
printB();
//System.out.println("BBB");
add(10,20);
add(20,10);
add(10,23);
int sum=add(10,50); //带返回值的函数 实参
System.out.println("sum="+sum);
}
//函数不可以嵌套 ，在类里边写
//定义一个函数主要用于打印输出AAA
public static void printA() {
System.out.println("AAA");
}
//定义一个函数主要用于打印输出BBB
public static void printB() {
System.out.println("BBB");
System.out.println("==================================");
}
//定义一个函数，专门用于计算俩个数的和
int a=10;
int b=20;
//将俩个数的和通过返回值（出口）返回回来
public static int add(int a,int b) {
//void 空的，无返回值
System.out.println("a="+a);
System.out.println("b="+b);
System.out.println("a+b="+a+b);
int sum=a+b; //形参
return sum; //return返回值 sum
}
函数的重载Overload：
函数名相同，参数不同。
===一个类里面有俩个方法（函数），用的相同的名字只是参数不同
public class ChongZai {
public static void main(String[] args) {
int sum=add(10,20);
System.out.println(sum);
String s=add(10,"20");
System.out.println(s);
int b=add(10,20,30);
System.out.println(b);
String s1=add("aaa",10);
System.out.println(s1);
}
//定义一个函数，计算俩个数的和
public static int add(int a,int b) {
return a+b;
}
//重复调用
// public static int add(int a,int b) {
// return a+b;
// }
//定义一个函数，计算三个数的和
public static int add(int a,int b,int c) {
return a+b+c;
}
//类型不一样
public static String add(int a,String b) {
return a+b;
}
//类型不一样/顺序也不一样
public static String add(String a,int b) {
return a+b;
}
}
可变参数：
当传入函数的参数个数不确定时，可以使用...语法来定义可变参数，可变参数本质上是一个数组，在函数内部可以当作数组一样取操作。
注：1.如果函数中除了可变参数，还有其他类型的参数，那么可变参数必须要写在参数列表的最后面
2.在函数中最多只允许出现一次可变参数。
public class KeBianCanShu {
public static void main(String[] args) {
int [] arr= {10,20,30};
int sum=add(arr);
System.out.println(sum);
}
//定义一个函数，用于累加若干个整数和
//传入几个整数，就累加这几个整数并返回
// public static int add(int arr[]) {
// int sum=0;
// for(int i=0;i
函数递归：
函数自己调用自己或者俩个函数互相调用
注意：递归必须指定结束条件，否则StackOverflowError，栈内存溢出。
递归效率比较低，尽量避免使用。
使用场景：
求阶乘
求斐波那契数列
快速排序
二叉树
文件夹遍历
数据库自连接
······
public class DiGui {
public static void main(String[] args) {
a();
int jc=f(3);
System.out.println(jc);
}
//递归：函数相互调用
//能结束的递归：正向递归 不能结束的：反向递归
//自己也可以调用自己
public static void a() {
System.out.println("aaa");
b(); //在a里边调用b的函数
}
public static void b() {
System.out.println("bbb");
// a(); //b里调用a
}
//递归的引用 阶乘!
public static int f(int x) {
if(x==1) {
return 1;
}
return x*f(x-1);
}
标识符：
由程序员自己定义的包名、变量名、和函数名；
-
强制性规范
能使用：字母、数字、下划线、、$组成
不能以数字开头
不能使用java中的关键字：
-
建议性规范
变量名和标识符遵循小驼峰命名法：
有多个连续的单词充当变量名时，第一个单子首字母小写，后边的单词每个首字母大写。
例：------int classRoomCount
变量/标识符命名要见名之意：年龄----age
类名
类名要遵循大驼峰命名法：首字母大写、有多个连续的单词充当类名时，每个单词首字母大写。
包名
首字母建议小写、包名命名建议为公司域名的倒置--------com.公司.项目名.模块名
