方法的定义
在程序之中很多情况下是有可能需要重复执行一些代码的。在有一些书上也会把方法（method）称为函数（function）。需要注意一点，本次进行方法定义的时候有一个前提：方法在主类中定义，并且由主方法直接调用。
本次方法是定义在主类之中并且由主方法直接调用，所以方法的定义语法形式如下：
public static 返回值类型 方法名称([参数类型 变量,...]) {
// 该方法要执行的代码
[return [返回值] ;]
}
以后会在此基础上扩充
[]是可选的
对于“返回值”而言就可以使用Java中定义的数据类型了（基本数据类型和引用数据类型），在方法之中可以进行返回数据的处理，如果要返回数据则可以使用return来描述，return所返回的数据类型与方法的返回值类型相同，如果不返回数据，则该方法可以使用void进行声明。
关于方法名称与变量的定义命名要求：
在进行“方法”名称定义的时候要求第一个单词的字母小写，而后每个单词的首字母大写；
在进行“变量”名称定义的时候要求第一个单词的字母小写，而后每个单词的首字母大写；
范例：定义一个无参无返回值的方法
public class JavaDemo {
public static void main(String args[]) {
printMessage() ; // 执行方法调用
printMessage() ; // 执行方法调用
}
public static void printMessage() { // 不返回数据，则该方法可以使用void进行声明；
System.out.println("****************") ; // 该方法包含了三行代码，注意：方法中只写核心的几个步骤即可，不能有千百行的代码，否则太多就不能看了
System.out.println("* www.fgq.cn *") ;
System.out.println("****************") ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
****************
* www.fgq.cn *
****************
****************
* www.fgq.cn *
****************
方法的本质就是方便使用者进行重复的调用，并且所有的程序一定都是通过主方法开始执行的。
范例：定义一个有参有返回值的方法
public class JavaDemo {
public static void main(String args[]) {
String result = get(20.0) ;
System.out.println(result) ; // 不想直接输出返回值，此处可以做个接收
System.out.println(get(1.0)) ; // 返回值可以直接输出
}
public static String get(double money) {
if (money >= 10.0) {
return "给你带一份快餐，找零：" + (money - 10.0) ;
} else {
return "对不起，您的余额不足，请先充值，或者捡漏。" ;
}
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
给你带一份快餐，找零：10.0
对不起，您的余额不足，请先充值，或者捡漏。
写代码时，总有一些程序在进行复制和粘贴的时候，此时就需要考虑是否可以定义成方法，包装起来，以便下次使用。
在进行方法定义的时候，如果方法的返回值类型为void，那么可以利用return来结束调用。
范例：使用return结束方法调用
public class JavaDemo {
public static void main(String args[]) {
sale(3) ;
sale(-3) ;
}
public static void sale(int money) {
if (money <= 0) { // 余额不足
return ; // 后续代码不执行了
}
for (int x = 1 ; x <= money ; x ++) {
System.out.println("老王开笑，第" + x + "次") ;
}
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
老王开笑，第1次
老王开笑，第2次
老王开笑，第3次
如果从定义的语法来讲，方法并不是一个难以理解的概念，就是一段可以被重复调用的一块代码而已，但是良好的方法设计是需要根据你实际的开发经验慢慢累积的，但是请千万记住一点：在Java定义方法的时候一般都不可能太长。最多几十行就够了。
方法重载
方法重载的定义：当方法名称相同，参数的类型或个数不同的时候就称为方法重载。下面通过一个程序做一个简单的分析。
现在要定义一个加法处理方法，该方法可以接收两个int变量、三个int变量、两个double变量的加法处理。
范例：采用方法重载进行定义
public class JavaDemo {
public static void main(String args[]) {
int resultA = sum(10,20) ; // 调用两个int参数的方法
int resultB = sum(10,20,30) ; // 调用三个int参数的方法
double resultC = sum(10.2,20.3) ;
System.out.println("加法执行结果：" + resultA) ;
System.out.println("加法执行结果：" + resultB) ;
System.out.println("加法执行结果：" + resultC) ;
}
public static int sum(int x,int y) {
return x + y ;
}
public static int sum(int x,int y,int z) {
return x + y + z ;
}
public static double sum(double x,double y) {
return x + y ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
加法执行结果：30
加法执行结果：60
加法执行结果：30.5
这个时候可以发现同一个方法名称，但是可以根据调用时传递的不同参数的类型或个数实现不同方法体的调用，这样就实现了方法重载的定义。
范例：观察一个程序代码
public class JavaDemo {
public static void main(String args[]) {
System.out.println(1) ;
System.out.println(1.1) ;
System.out.println(true) ;
System.out.println('A') ;
System.out.println("Hello World !") ;
}
}
现在可以发现，所有的输出操作支持有各种数据类型，所以System.out.println()本身就属于一个方法重载。
方法递归调用（了解）
方法的递归调用指的是一个方法自己调用自己的情况，利用递归调用可以解决一些重复且麻烦的问题。
在进行方法递归调用的时候，一般需要考虑如下几点问题：
一定要设置方法递归调用的结束条件；
每一次调用的过程之中一定要修改传递的参数条件。
范例：实现一个1~100的累加
while循环
public class JavaDemo {
public static void main(String args[]) {
int sum = 0 ;
int x = 1 ;
while ( x <= 100) { // 循环结束的条件
sum += x ;
x ++ ; // 修改每一次循环的变量
}
System.out.println(sum) ;
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
5050
递归调用
public class JavaDemo {
public static void main(String args[]) {
System.out.println(sum(100)) ;
}
public static int sum(int num) { // 执行累加
if (num == 1) { // 不累加了
return 1 ;
}
return num + sum(num - 1) ; // 递归调用
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
5050
下面就对上面的代码进行分析处理：
sum(100) sum这个方法两个地方发起调用：一个是主方法，一个是sum自己
【第1次执行sum()、主方法执行】return 100 + sum(99);
【第2次执行sum()、sum()递归调用】return 99 + sum(98);
... ...（中间经历了很多次的调用）
【第99次执行sum()、sum()递归调用】return 2 + sum(1);
【第100次执行sum()、sum()递归调用】return 1（此处执行if处的代码）
整体形势：return 100 +99+98+... ...+2+1;
递归操作虽然可以简化调用，但是实际的开发之中，你们所编写的代码很少会出现有递归情况。大部分情况下考虑的都只是一些简单的处理逻辑。递归少去使用还有另外一个原因：如果处理不当，则会造成内存溢出。
范例：计算 “1! + 2! + 3! + ... ... + 90!”
计算器得出 90! 的结果：
1.4857159644817614973095227336208e+138
在进行阶乘计算的时候必须要考虑选择的数据类型，肯定不能够使用int或long，只能够使用double。如果阶乘更大，double也会装不下，就要考虑其他数据类型。
90! 的代码
public class JavaDemo {
public static void main(String args[]) {
System.out.println(fact(90)) ;
}
public static double fact(int num) { // 执行累加
if (num == 1) { // 不累加了
return 1 ;
}
return num * fact(num - 1) ; // 递归调用
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
1.4857159644817607E138
1! + 2! + 3! + ... ... + 90! 的代码：
public class JavaDemo {
public static void main(String args[]) {
System.out.println(sum(90)) ;
}
public static double sum(int num) {
if (num == 1) {
return 1 ;
}
return fact(num) + sum(num - 1) ;
}
public static double fact(int num) { // 执行累加
if (num == 1) { // 不累加了
return 1 ;
}
return num * fact(num - 1) ; // 递归调用
}
}
D:\fgqjava>javac JavaDemo.java
D:\fgqjava>java JavaDemo
1.502411534554385E138
实际上有一部分的递归都是可以通过循环来完成，但是如果使用递归要比使用循环结构看起来更加清晰一些。递归操作知道这种形式就可以了，不建议过多精力研究，清楚原理即可。
