一、基本概念
以一个人抽烟为例，如果他每次抽烟都要求自己去种烟草，自己进行加工、卷烟，那么如果把这些步骤想象成20行代码，那么请问：这个时候如果他重复去做这些操作肯定很麻烦，于是他会将这些步骤封装好，最终封装的结果就成了一根根可以拿来使用的烟。
如果将20行代码归纳的话，可以简单的理解就是一个方法，所以所谓的方法就是指一段可以被重复调用的代码段，利用此操作可以封装执行的代码。
但是在Java之中，方法的定义格式比较复杂，所以本次给出的方法有一个要求：
指的是定义在主类之中，并且由主方法直接调用的方法。
方法创建语法：
public static 返回值类型 方法名称（参数类型 参数变量，…）{
方法体（本方法要执行的若干操作）；
[return[返回值]；]
}
在本方法的定义格式之中，发现方法有一个返回值类型，指的是这个方法返回结果；对于此类的类型可以有两种：
- 直接设置Java中的数据类型（基本数据类型、引用数据类型），如果方法设置了返回值，必须使用return语句返回与之数据类型对应的数据；
- 方法没有返回值：void，可以不使用return返回内容，但是可以使用return结束方法调用。
注意：在定义方法名称的时候，一个单词的首字母小写，而后每个单词的首字母大写。
范例：定义一个没有返回值的方法
public class TestDemo { public static void main(String args[]) { printInfo();// 直接调用方法 printInfo();// 直接调用方法 printInfo();// 直接调用方法 } // 定义没有参数，没有返回值的方法 public static void printInfo() { System.out.println("***************"); System.out.println("*Hello World!*"); System.out.println("***************"); } }
可以发现将若干代码封装在一个方法之中，就可以根据需要重复执行这些方法所定义的代码。实际上是否要形成方法并没有一个绝对的条件。但是有一点可以作为参考：如果在代码之中发现你总是在对一些代码进行复制粘贴的时候，就可以考虑将此类代码定义为方法以供重复调用使用。
范例：定义一个有参数，无返回值的方法
public class TestDemo { public static void main(String args[]) { get(10.0); } // 定义有参数，无返回值的方法 public static void get(double money) { if (money > 0.0) { System.out.println("可以进行支付!"); } else { System.out.println("支付不起"); } } }
有了参数之后，那么方法就可以根据不同的参数内容进行数据的处理。
范例：定义有返回值，有参数的的方法
public class TestDemo { public static void main(String args[]) { // 方法的返回值可以进行接收 int result = add(10, 20); System.out.println("计算结果:" + result); // 也可以直接将方法返回值进行输出 System.out.println(add(50, 60)); } public static int add(int x, int y) { return x + y; } }
在以后编写代码的时候为了节约代码，可以直接利用方法的返回结果进行输出。
如果说现在一个方法上使用void定义为它的返回值，那么可以使用return结束一个方法的调用，这时候并不会返回内容。
范例：利用return结束方法的调用
public class TestDemo { public static void main(String args[]) { set(100); set(3); set(10); } public static void set(int x) { if (x == 3) { return;// 方法后面的内容不执行了 } System.out.println("x=" + x); } }
只有在方法返回值类型为void的前提下才可以使用。
二、方法重载
如果现在有一个方法名称，有可能要执行多项操作，例如：一个add()方法，它可能执行两个整数的相加，也可能执行三个整数的相加，或者可能执行两个小数的相加，那么在这样的情况下，很明显，一个方法体肯定无法满足我们的要求，需要为add(）方法定义多个不同功能的实现，所以此类的功能就称为方法重载，但是在进行方法重载的时候，要求方法的名称相同，参数的类型及个数不同。
范例：观察方法重载
public class TestDemo { public static void main(String args[]) { // 方法重载之后执行时会根据传入参数的类型或个数的不同调用不同的方法体 System.out.println("两个整形参数：" + add(10, 20)); System.out.println("三个整形参数：" + add(10, 20, 30)); System.out.println("两个浮点型参数：" + add(10.2, 20.3)); } // add()方法一共被重载3次 public static int add(int x, int y) { return x + y; } // 此时与之前的add()方法的参数个数不一样 public static int add(int x, int y, int z) { return x + y + z; } // 此时与之前的add()方法的参数类型不一样 public static double add(double x, double y) { return x + y; } }
下面继续观察一个代码
范例：输出信息
public class TestDemo { public static void main(String args[]) { System.out.println("hello"); System.out.println(1); System.out.println(10.2); System.out.println('A'); System.out.println(false); } }
可以发现“System.out.println()”所有的内容都可以输出，所以此方法就是被重载后的方法。
方法重载的概念本身很容易理解，但是对于方法重载有两点说明：
- 在进行方法重载的时候一定要考虑参数问题的统一上，虽然可以实现重载方法返回不同类型的操作，但是根据标准开发来讲，建议所有的重载后的方法使用同一种返回值类型；
- 方法重载的时候重点是根据参数类型及个数来区分不同的方法，而不是依靠返回值的不同来确定的。
三、递归调用
递归调用是我们迈向数据结构开发的第一步。现在在标准的项目开发里面，很难去写上递归调用。
所谓的递归调用指的是一个方法自己调用自己的情况，但是如果想要实现自己调用自己，一定需要一个结束的条件。并且每次调用的时候都需要去修改这个结束条件。
如果递归操作处理不得当，就有可能出现内存的溢出问题。
范例：实现一个1 ~ 100的累加操作
public class TestDemo { public static void main(String args[]) { int sum = 0; int current = 1; while (current <= 100) { sum += current; current++; } System.out.println(sum); } }
范例：递归调用
public class TestDemo { public static void main(String args[]) { System.out.println(sum(100)); System.out.println(sum(200)); } public static int sum(int num) { if (num == 1) {// 递归的结束调用 return 1;// 最终结果返回了一个1 } return num + sum(num - 1);// 递归调用 } }
使用方法调用的方式分析以上代码的操作步骤：
- return 100+99+98+97+…+2+2；
- 主方法调用sum(100)，renturn 100+sum(99)；
- 递归调用sum(99)，return 99+sum(98)；
- 递归调用sum(98)，return 98+sum(97)；
- ………………
- 倒数第二次递归调用sum(2)，return 2+sum(1)；
- 倒数第一次递归调用sum(1)，return 1，不再递归，符合结束条件。
四、总结
- 可以将一些重复执行的代码定义在方法里面，方法（Method）在有些书里面也成函数（Function）；
- 本次所讲解的方法有它自己的局限性：定义主类，并且由主方法直接调用；
- 方法的返回值一旦定义了，就需要return返回相应数据；
- 方法重载（Overloading）指的是方法名称相同，参数类型及个数不同，同时尽量保证返回值类型相同；
- 递归调用需要明确设置一个结束的条件，否则就会出现死循环，如果处理的数据量过大，就会出现数据溢出。