1、什么是方法？
在java的类库中已经有很多定义好的工具类，在类中封装了执行某些特定功能的代码段。这就是方法，在其他语言中也叫做函数。对于一些复杂的代码逻辑，如果希望重复使用这些代码，并且做到“随时任意使用”，那么就可以将这些代码放在一个大括号“{}”当中，并且起一个名字。使用代码的时候，直接找到名字调用即可。这样做的好处就是，能够提高代码的复用性。
2、接触的第一个方法
我们在学习中所接触的第一个方法就是main方法，main方法是程序的入口（主函数），在main方法中编辑的代码是可以被正常执行的代码，首先来看一下main方法是由哪些内容组成的：
主方法：
public static void main(String[] args){
//代码块
}
public：公有的，最大的访问权限
static：静态的，无需创建对象
void:：表示没有返回值，执行时没有返回结果
main：方法名，固定的方法名
String[] args：表示参数为字符串数组，可以在调用方法时传入参数
实际上我们在学习过程中已经接触过很多方法了，这里举几个例子：
String s = "我有一头小毛驴我从来也不骑，有一天我心血来潮骑它去赶集。";
//声明一个字符串s,储存一串字符
int length = s.length();
//声明一个整型变量length，储存字符串s的长度
//这里使用的就是获取字符串长度的length()方法int[] a = {12,34,56,22,0,2,45};
//声明一个整型数组，储存大量int类型数据
String str = Arrays.toString(a);
//声明一个字符串str，储存数组转成的字符串
//这里使用的就是将数组整体转化为字符串的toString()方法3、访问权限修饰符
main方法的访问权限public ，表示该方法是公共的公开的，访问权限从大到小依次是：
public（公开的）> protected(受保护的) > default(默认的，不写修饰符就是默认的) > private (私有的)
4、静态修饰符
static静态修饰符，由静态修饰符修饰的方法就是静态方法，没有static修饰的方法就是非静态方法。静态方法和非静态方法，在调用时有明显的区别。
Random ran =new Random();
//调用Random类中的非静态方法
//需要使用该类的引用变量ran
int index = ran.nextInt();
//调用此方法必须创建Random类的引用对象
int[] a = {12,34,56,22,0,2,45};
//而静态方法只需要类名.方法名() 即可调用
Arrays.sort(a);5、返回值类型
返回值类型就是调用方法时，该方法是否返回某些特定的值。比如调用字符串的length()方法，会返回字符串的长度，是一个int类型的值。那么就可以看出来，length()方法的返回值类型是int类型。当不需要返回值时，可以定义为void（无返回值的）。
注意：无返回值的方法，不能放在输出语句中直接输出，会报错。
String s = "我有一头小毛驴我从来也不骑，有一天我心血来潮骑它去赶集。";
System.out.println(s.length());
//可以输出，length()方法的返回值是int，相当于输出了int类型的数字
int[] a = {12,34,56,22,0,2,45};
//System.out.println(Arrays.sort(a));
//编译错误，不可以直接输出，sort()方法没有返回值。6、方法签名
方法的签名由两部分组成，方法名(参数列表)，即一个方法的名字。调用方法时，使用方法名，在括号内传递对应类型的参数，才能正常的调用方法。
形参：定义方法时，在方法名后边的括号内定义的参数。只有参数类型以及参数名，并没有确切的值。
实参：在调用方法时，方法名后边的括号内传递进来的参数，是一个确切的值。如果与形参类型不符合，则会提示报错。
举个例子：
public static void m1(int a) {//在这里int类型的a是形参
}
public static void main(String[] args) {
m1(100);//在调用方法m1时，括号内的100是实参
m1(100.3);//参数类型不符合会报错
}7、方法的定义
定义方法时一般有以下几种情况：
1、无参数无返回值的
2、无参数有返回值的
3、有参数无返回值的
4、有参数有返回值的
void m1() {//无参数无返回值
}
int m2() {//无参数有返回值
return 1;
}
void m3(String s) {//有参数无返回值
}
boolean m4(int a) {//有参数有返回值
return true;
}定义方法时基本上就是以上几种情况，可以选择加或者不加访问权限修饰符和静态修饰符，但是返回值类型和方法签名是必不可少的。
注意：有返回值的方法，必须在方法体中，使用return关键字，返回对应类型的值。比如你定义的方法返回值是int类型，那么在大括号中就必须有 return 整数数字; 如果return后的数据类型与返回值类型不同，也会报错。
在java中，return关键字和break关键字的作用相似，在当前这行代码使用return关键字时表示代码到此运行结束，下边的代码都不会再执行了。如果写了就会报错。
8、方法的调用
方法定义好了之后，没有被调用是不会执行的。换句话说方法只有在调用时才执行。
静态方法：在本类中可以直接使用方法名(参数)调用，在其他类中使用类名点方法名(参数)调用
非静态方法：在任何地方调用，都需要创建类的引用对象，使用引用对象点方法名(参数)调用
注意事项
1.可以没有权限修饰符，静态修饰符，但是不能没有返回值类型及方法名和参数列表
2.返回值必须和返回值类型对应。
3.参数如果有多个，需要使用逗号分隔。
4.参数如果没有，小括号则可以留空。
5.多个方法的定义先后顺序无所谓。
6.不能在一个方法内部定义方法。
7.方法定义之后，没有调用就不会执行；要想执行，一定要调用它。
9、方法的重载
如果有两个方法的方法名相同，但参数不相同，就可以说一个方法就是另一个方法的重载
方法重载的具体说明
1、方法名相同
2、方法的参数类型不同，参数个数不同
3、方法的返回类型可以不相同
4、方法的修饰符可以不相同
5、main方法也可以被重载
举个例子：
比如说我们使用过的Arrays.sort（）方法，同一个名字的方法有很多个，但是细心的同学会发现，每个方法的参数类型或者个数都是不同的。在调用时，系统会自动根据传递的参数，调用对应的重载方法。
public static void main(String[] args) {
m1();
m1(100);
m1("哈哈");
m1(10,20);
}
static void m1() {
System.out.println("无参方法");
}
static void m1(int a) {
System.out.println("重载的有参方法");
}
static void m1(String a) {
System.out.println("重载的方法参数类型不同");
}
static void m1(int a,int b) {
System.out.println("重载的方法个数不同");
}运行结果：
无参方法
重载的有参方法
重载的方法参数类型不同
重载的方法个数不同10、递归
递归，是方法调用方法自身的一种特殊算法。
举个例子：《盗梦空间》这个电影，我们把入梦这个能力理解为一个方法，再梦境中使用入梦的能力，进入到下一层的梦境，也就是在方法中调用自身的方法的过程。如此循环调用下去，直到在最后一层梦境中，找到了问题的真相之后，再逐个梦境一层一层的返回来。
再举个例子：我们可以把” 递归 “比喻成 “查字典 “，当你查一个词，发现这个词的解释中某个词仍然不懂，于是你开始查这第二个词。可惜，第二个词里仍然有不懂的词，于是查第三个词，这样查下去，直到有一个词的解释是你完全能看懂的，那么递归走到了尽头，然后你开始后退，逐个明白之前查过的每一个词，最终，你明白了最开始那个词的意思。
这里演示一下递归的用法，用一个经典的案例九九乘法表：
public static void main(String[] args) {
m1(9);
}
//定义一个方法用来实现递归
static void m1(int i){
if(i==1){
System.out.println("1*1=1");
}else{
m1(i-1);
for(int j=1;j<=i;j++){
System.out.print(j+"*"+i+"="+j*i+"\t");
}
System.out.println();
}
}
运行结果：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
拓展：可变长参数
在java5提供了可变长参数，也就是在方法定义中可以使用个数不明确的参数，对于同一个方法可以使用不同个数的参数调用。
举个例子：
public static void main(String[] args) {
m1();//调用此方法时可以没有参数
m1(1);
m1(1,2,3,4);//可以有1个或多个参数
}
static void m1(int... a) {
// int... 代表可变长参数类型为int 可以有多个参数，用逗号隔开
// 可以理解为一个特殊的数组类型。
for (int i = 0; i < a.length; i++) {
System.out.println("第"+(i+1)+"个参数是"+a[i]);
}
}目录
984
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
