Java 用函数的模块化思想来设计程序
在学习Java中的函数之前，大家是否了解了点函数了呢？无论有没有了解过函数，接下来就看看我一个Java小白对函数的理解吧
为什么要有函数呢？
软件工程的中心目标之一是程序的模块化和可重用性，Java中提供的了一些有助于完成这目标的有效结构，这种结构就叫做函数或方法。
当然Java中也有自带的常用函数（点击~~>常用函数，即可查看）以下主要介绍的是程序员自定义的函数：
下面介绍函数在Java中的结构(即语法)：
public static void main(String[] args){
函数体;
}这是Java初学者遇到的第一个函数，我们称它为main函数（主函数）；
让我们看看这个函数是由什么构成的：
函数的权限 public主函数是公开权限（最大权限）
函数的状态类型 static主函数是静态函数
函数的返回值类型 void该函数没有返回值
函数名 main主函数的名称
括号内的是参数（可以是一个，也可以是多个） String[] 表示的是一个字符串数组(数据类型)
args 就是这个数据类型的变量名称函数体{}内 是函数具体执行的部分执行到最后会由return；来结束函数，也称函数的弹栈（这是函数栈性执行的特点，在下文中会详细介绍）。如果后面跟着一个返回值（若没有返回值，return可以省略），那么函数弹栈时会有返回值返回到调用的函数中（函数之间的调用在下文详细介绍）
所以函数的结构组成就是：
权限 状态类型 返回值类型 函数名(参数){
函数体;
return 返回值;
}
了解了函数结构后那我们就来敲代码吧！！（体现一下函数的作用）
来编写一个能算
的值的程序，其中a为任意实数，x为任意整数，代码可以算出任意个值。
在没学函数之前我们会将代码都写在main函数中,代码如下：
如果我们要在程序结束前算多个值，就需要重复写多次相似的代码，程序看上去就会比较繁杂
class Demo{
public void main(String[] args){
//算2^4
double a = 2;
int x = 4;
double sum = 1;
if(x==0 && a!=0){
System.out.println(1);
return;
}
for(int i = 1;i<=x;i++){
sum = sum*a;
}
System.out.println(sum);
//算4^6
double a1 = 4;
int x1 = 6;
double sum1 = 1;
if(x1==0 && a1!=0){
System.out.println(1);
return;
}
for(int i = 1;i<=x1;i++){
sum1 = sum1*a;
}
System.out.println(sum1);
}
}接下来我们使用构造出一个函数来解决问题，代码如下：
class Demo{
public static void main(String[] args){
double sum1=pow(2,4); //调用函数的语句。如果要算多个值，只需多调用这个语句，写上参数即可
double sum2=pow(4,6);
System.out.println(sum1);
System.out.println(sum2);
}
public static double pow(double a,int x){
double sum = 1;
if(x==0 && a!=0){
return sum;
}
for(int i = 1;i<=x;i++){
sum = sum*a;
}
return sum;
}
}这样写出的代码就模块化了，看上去也不繁杂。
注意：千万不要在函数的内部创建函数 函数必须在类里面 函数们之间是平级关系
在Java当中函数的定义在函数调用之前后都可以
不知道大家有没有看懂构造一个函数来解决问题的代码？没有看懂的话也没有关系，下面听我细细道来：
首先说明代码执行的流程：
从main函数开始：double sum1=pow(2,4);开始调用函数，将参数2与4分别传给了pow()函数中的 a 与 x 。此时局部变量a=2，x=4。我们将这里的2、4称为实际参数，a、x称为形式参数，且传的2、4在常量池中的地址。
将传参数、调用pow之后，接下来执行pow内的函数体（函数的调用）：
double sum = 1;定义了一个double类型变量将1赋值给sum。接下来用if来判断x在a不等于的情况下是否为0，若为x为0则直接return返回sum的值，（
当a不等于0且x为0时，结果为1，就是sum的初始值1。若x不为0，则进入for循环，将a进行累乘的结果赋给sum，结束循环后return返回sum的值，函数pow()执行结束（弹栈）。返回值赋给了main中的变量sum1。
返回main函数：double sum2=pow(4,6);与上述流程一样（不重复说明）执行后，再执行System.out.println(sum1);输出sum1的值，System.out.println(sum2);同样输出sum2的值。
最后main函数后还有一个隐藏的return语句：执行后结束main函数，程序结束。
以上就是代码执行的流程，下面用流程图演示 传参与栈性执行特点：
函数栈：
函数的执行流程就像栈的特点，我们知道栈具有先进后出的特点。
函数执行时，main函数先入栈，此时main函数是栈顶，执行main函数，当调用其他函数时（如上述的pow()函数），被调用的函数就会入栈成为栈顶，这时main函数进行等待，栈顶的函数先执行，执行完后该函数弹栈，接下来再执行main函数的剩余部分。
函数运行的流程就是解释到这里啦！！
函数的重载：
函数重载是在代码中出现同名的函数，它们之间可以不同的是参数的数量与类型，执行内容。
函数重载的好处就在于我们可以扩展函数的功能，下面我就举个例子：
写一个max()函数来判读两个数据的大小
首先我们想到的是判断两个整数的大小，代码如下：
class Demo{
public static void main(String[] args){
System.out.println(max(22,5));
}
public static int max(int a,int b){
int max;
if(a>b){
max=a;
}else{
max=b;
}
return max;
}
}如果这时我们想比较两个浮点数的大小，我们就可以将函数重载，将下面的重载函数添加到上例代码中即可：
public static double max(double a,double b){
double max;
if(a>b){
max=a;
}else{
max=b;
}
return max;
}如果我们想比较二个字母的大小，也可以将函数重载，函数重载的代码如下：
public static char max(char x1,char x2){
char max;
if(a>b){
max=a;
}else{
max=b;
}
return max;
}函数重载后，当调用函数时，会自动根据参数类型或参数个数来寻找适当的函数，寻找函数会有以下几点规则：
寻找适当函数的规则
1.看是否有确切的参数定义 int+int 查看是否有(int,int)
2.看是否有可兼容的参数定义 int+int 查看是否有(double,double)
3.如果可兼容的参数定义有多个int+int、(double,int)或(int,double)此时报错 引用不明确（这里未举例）
函数的递归调用
函数调用自身的操作称为递归，递归流程：当函数在执行时，函数体中有调用自身的函数存在时，会先调用自身，如果函数不弹栈，那么该调用会一直重复，就好比死循环一样。所以程序员需要让函数在一定条件下弹栈。
递归有三个过程：
前进段：指递的过程，调用自身，将大问题化小
结束段：问题已经化到最小，解决最小的问题
返回段：将最小问题解决完后，向着大问题返回
下面是递归调用的流程：
递归就是函数在进栈，递归的次数越多，内存占的越大，是无法避免的。
那么递归能解决哪些问题呢？
一般而言，循环能解决的问题用递归也能解决，但是递归能解决的问题循环不一定能解决。
递归是分治法的一种实现方式，分治法就是将一个大问题拆成一个个小问题求解，最后再将这些解合并。
下面用递归的方法来寻找斐波那契数列：
斐波那契数列：1 1 2 3 5 8 13 21……，除第1、2项外，其他项等于前两项的和。
寻找前20位斐波那契数列代码如下：
class Demo{
public static void main(String[] args){
for(int i=1;i<=20;i++){
System.out.println(fbnq(i));
}
}
public static int fbnq(int n){
int temp;
if(n==1|n==2){
return 1;
}else{
return fbnq(n-1)+fbnq(n-2);
}
}
}fbnq(n)是求出第n项的斐波那契数的一个函数，当n=1时为1，n=2时为1，当n=3时该函数会先调用自身得到第一、二项的值，然后才得出第三项……当n=20时如下：
求第20项先求第18、19项，
求19项先求17、18项，求18项先求16、17项
求17项先求15、16项，…………
…………求到第1、2项，然后返回给第3项，
2、3项返回给第4项，…………
直到返回到第20项。
还有一个用递归解决的经典题就是汉诺塔（点击 ~~> 汉诺塔，即可阅读解析）