一、 Java中的方法
需求：求整数10和整数3的乘积，然后在求整数2000和整数300的乘积。
|
public class MethodTest01 { public static void main(String[] args){ int i = 10; int j = 3; int k = i * j; System.out.println("i * j = " + k); int l = 2000; int m = 300; int n = l * m; System.out.println("l * m =" + n); } } |
功能已经实现，但是存在的问题是，两段代码完成的功能相同，数据的类型也相同。只是具体的数据不同。并且代码重复使用了两次，虽然实现了功能，但缺点是相同功能的代码不能实现重用。所以在Java中可以使用方法来实现相同功能的代码块重复利用。
1.1 方法的定义
方法就是一段代码片段，可以完成特定的功能，并且可以重复利用。定义方法的语法格式如下。
|
[方法修饰列表] 返回值类型 方法名(方法形式参数列表){ 方法体; } |
方法修饰符：可以是public、protected、private、abstract、static、final和synchronized。注意：其中public、protected和private不能同时存在，只能是其中之一。
方法的返回值类型：可以是Java语言中的任何一种数据类型(基本数据类型和引用数据类型)。如果该方法执行结束之后，没有任何返回值，那么定义方法的时返回值类型为void。如果存在返回值，使用 return语句。Return语句后面不能再执行语句，因为不可能会执行到，编译不能通过。
方法名：合法的标识符。
方法参数列表：定义方法时可以有参数，也可以没有参数，如果有多个参数，参数之间要使用逗号进行分隔。
定义一个方法实现上面的需求。
|
public class MethodTest02 { public static void main(String[] args){ // 调用static修饰的静态方法需要使用类名.的方式 // 直接调用方法并传入需要乘积的参数 MethodTest02.method(10, 3); MethodTest02.method(2000, 300); } // static修饰的方法是静态方法 public static void method(int i,int j){ int product = i * j; System.out.println("i * j = " + product); } } |
定义方法。
|
public class MethodTest03 { public static void main(String[] args){ // 调用方法，静态方法直接使用类名.的方式进行调用 MethodTest03.method01(); // 调用方法时同时传递参数给方法 MethodTest03.method02("张三"); // 调用有返回值的方法 int product = MethodTest03.method03(20, 30); System.out.println("product = " + product); } // 定义方法 // public 公共的，外面的类可以调用 // static 方法是静态的 // void 没有返回值 // method01 方法名 // 方法没有参数 public static void method01(){ System.out.println("Hello Java"); } // 方法带有一个String类型的参数 // 参数name是局部变量，作用域在方法体内 public static void method02(String name){ System.out.println(name); } // 方法有两个int类型的参数 // 方法有返回值，返回值类型为int类型 public static int method03(int i,int j){ int product = i * j; // 方法有返回值，必须有return语句，并且返回值的类型与方法定义的类型 // 相同，否则编译不能通过 return product; // return 语句后面不能存在其他语句，否则编译不能通过 // System.out.println("product = " + product); } } |
1.2 方法的调用
静态方法的调用原则。在同一个类中，调用静态方法可以使用类名.的方式进行调用，也可以直接使用方法名进行调用。
|
public class MethodTest04 { public static void main(String[] args){ // 在同一个类中，可以直接使用方法名调用静态方法 method02(); // 也可以使用类名的方式调用静态方法 MethodTest04.method02(); // 不在同一个类中的静态方法必须使用类名.的方式进价调用 A.method03(); } public void method01(){ method02(); MethodTest04.method02(); } public static void method02(){ System.out.println("Hello Java"); } } class A{ // 在A类中定义的静态方法 public static void method03(){ System.out.println("A method03()"); } } |
调用带参数的静态方法，需要传递相应类型的参数。通常情况下调用有返回值的方法就是要取得返回值，返回值变量的类型必须与方法返回值的类型相同。在方法中，return语句执行则方法结束，执行流程放回到方法调用处。
|
public class MethodTest05 { public static void main(String[] args){ // 调用有返回值的静态方法 int success = method01(true); // 返回值类型是方法的返回值类型 // 参数的类型必须是方法定义的参数类型，并且顺序相同 int product = method02(10,3); System.out.println("product: " + product); // 不在同一个类中，必须采用类名.的方式调用静态方法 A.method03("张三"); } // 静态方法 public static int method01(boolean b){ /* if(b){ return 1; }else{ return 0; } */ if(b){ return 1; } return 0; } // 静态方法，返回值类型是int型，两个参数。形式参数类型是int public static int method02(int i,int j){ // 返回值的类型必须是方法定义的返回值类型 return i / j; // return语句执行，方法结束，所以不能有语句在return后面，编译不能通过 // System.out.println(i / j); } } class A{ // 定义的静态方法 public static void method03(String name){ System.out.println("name: " + name); } } |
如何终止方法的执行，采用的方式是如果符合某种条件，使用return语句终止方法的执行。
|
public class MethodTest06 { public static void main(String[] args){ method01(11); method01(8); } // 静态方法，没有返回值，一个形式参数，类型是int public static void method01(int i){ // 如果参数值大于10终止方法执行 if(i > 10){ // return语句执行，方法结束 return; } for(;i <= 10;i++){ if(i == 5){ // break只是结束终止循环 break; } System.out.println("i = " + i); } System.out.println("break后要执行的语句"); } } |
return语句的使用方式。
|
public class MethodTest07 { public static void main(String[] args){ // 静态方法调用 method01(); String info = method02(); System.out.println(info); } public static void method01(){ // 方法没有返回值，如果使用return，return后面不能存在语句 //return; // 编译可以通过，虽然最后的语句不会输出 if(true){ return; } System.out.println("HelloWord"); } public static String method02(){ // 如果方法有返回值，必须存在return语句，后面的值类型必须和返回类型 // 相同，并且return语句后面不能跟其他语句 //return "HelloWord"; // 这种方式可以， /* if(true){ return "HelloWord"; }else{ return "OK"; } */ // 这种方式可以 if(true){ return "HelloWord"; } return "OK"; // 方法有返回值，return语句一定是最后一条语句，否则编译不能通过 //System.out.println("HelloWord"); } } |
1.3 方法的重载
需求：定义三个方法，分别是int类型、double类型和long类型实现乘积的方法，方法有返回值。
|
public class MethodTest08 { public static void main(String[] args){ int product1 = productInt(10,20); System.out.println(product1); double product2 = productDouble(10.11,93.23); System.out.println(product2); long product3 = productLong(10L,20L); System.out.println(product3); // 注意：类型从小容量到大容量，自动类型转换 productInt(10,20); productDouble(10,20); productLong(10,20); } public static int productInt(int i1,int i2){ return i1 * i2; } public static double productDouble(double d1,double d2){ return d1 * d2; } public static long productLong(long l1,long l2){ return l1 * l2; } } |
上面的代码实现了功能，但是存在的问题是每个方法的方法名称不同，相同的是求两个数值类型的值的乘积。另外，还需要记忆多个方法名，并且代码不是特别易读。如果方法实现的功能相同，只是参数类型或者参数的数量不同，可以采用方法重载的方式，如下例子。
|
public class MethodTest09 { public static void main(String[] args){ int product1 = product(10,20); System.out.println(product1); double product2 = product(10.11,93.23); System.out.println(product2); long product3 = product(10L,20L); System.out.println(product3); } public static int product(int i1,int i2){ return i1 * i2; } public static double product(double d1,double d2){ return d1 * d2; } public static long product(long l1,long l2){ return l1 * l2; } } |
修改后，三个方法的方法名称相同，参数类型不同，返回值类型不同，但是调用时只需要传入不同类型的参数，不需要指定调用哪个方法，系统会根据参数的类型自动调用相应的方法并将结果返回。并且不需要记忆更多的方法名称。
方法重载的条件。
1．方法重载只出现在同一个类中
2．方法名相同
3．方法的参数类型，个数，顺序至少有一个不同
4．方法的返回类型可以不同(不依靠返回类型来区分重载)
5．方法的修饰符可以不同，因为方法重载和修饰符没有任何关系
|
public class MethodTest10 { public static void main(String[] args){ } // 方法重载必须在同一个类中 // 参数类型不同，是方法重载 public static void m1(int i1,int i2){} public static void m1(double d1,double d2){} // 参数数量不同，是方法重载 public static void m2(int i1){} public static void m2(double d1,double d2){} // 参数顺序不同，是方法重载 public static void m3(int i1,double d1){} public static void m3(double d1,int i1){} // 参数类型相同，参数个数相同，不是方法重载，是方法重复 //public static void m4(int a){} //public static void m4(int b){} // 参数类型和个数相同，返回值类型不同，不是方法重载， // 方法重载和返回值类型无关 //public static int m5(int i){} //public static void m5(int i){} // 参数相同，访问修饰符不同，不是方法重载，方法重载和访问修饰符无关 //private static void m6(){} //public static void m6(){} } |
方法重载举例。
|
public class MethodTest11 { public static void main(String[] args){ // sun提供的方法重载例子 System.out.println(10); System.out.println(23.2); System.out.println(true); System.out.println(‘A‘); } } |
1.4 类、方法、属性(静态变量)的关系
在一个类中，从类和成员的角度可分为静态的和成员的部分。静态的部分可分为静态变量、静态方法和静态内部类等等。成员的部分可以分为成员变量、成员方法和成员内部类等等。注意：也就是说，在类体中只存在两部分内容，一是属性(成员的或静态的)，二是方法(成员方法或静态方法)或内部类。那么可以执行的代码只能存在与方法中，包括成员方法或静态方法，所以，存在与方法中的代码是为了实现一个特定的功能，就像一个工厂生产特定的产品，方法的参数类似于工厂需要的生成原料，而方法的返回值相当于工厂生产出的产品。
|
public class MethodTest12 { // 类体 // 成员属性 int i = 10; // 静态变量 static String country = "中国"; // 成员方法 public void method01(int i){ // 方法体 // 可以执行的代码 // 将参数做一些特殊的处理 System.out.println(i); } // 静态方法 public static int method02(int i1,int i2){ // 方法体 // 可以执行的代码 // 实现特定功能，并返回特定的结果 return i1 + i2; } public static void main(String[] args){ // 方法体 // 可以执行的代码 // 程序的执行入口方法 } } |
1.5 调用方法的执行流程
1.5.1 栈的概念
当通过Java命令执行一个程序时，会启动一个JVM，Java虚拟机进程，并创建程序运行环境，会创建程序运行的栈内存，下面的图做了简单的说明。
1.1.1 程序的执行过程
下面通过一个程序说明程序的执行过程。
|
public class MethodTest13 { public static void main(String[] args){ // 调用method01()方法 method01(10); } // method01()方法调用method02()方法 public static void method01(int i){ method02(i); } // method02()方法调用method03()方法 public static void method02(int i){ method03(i); } public static void method03(int i){ System.out.println("i: " + i); } // method04()方法没有被调用 public static void method04(int i){ System.out.println(i); } } |
main()方法调用method01()方法，method01()方法调用method02()方法，method02()方法调用method03()方法，在method03()方法中将参数输出。下面通过一个图说明程序的执行流程。
注意：当方法被调用时，才会在内存中为方法分配空间。如果只是定义了方法，但是没有被调用，不会为方法在内存中分配空间。方法被调用时，Java虚拟机会为方法在栈内存中为方法分配空间。方法被调用时会发生压栈操作，当方法执行结束后会发生弹栈操作。
一、 递归
方法的递归调用就是方法自身调用自身。通常在树形结构访问时用到，如：目录的递归检索，又如权限管理中权限目录数的访问等等。下面的例子是递归的简单演示。
|
public class RecursionTest01 { public static void main(String[] args){ // 调用method01()方法 method01(10); } // 方法method01() public static void method01(int i){ // 方法自己调用自己，无限调用下去没有返回 method01(i); } } |
在上面的例子中，因为递归没有结束的条件，所以每调用一次method01()方法，就会在内存中开辟空间，产生压栈操作，但没有出栈操作，不会释放内存，会导致栈内存溢出错误！所以递归程序必须要有结束条件。
不使用递归计算1~n整数的和。
|
public class RecursionTest02 { public static void main(String[] args){ int sum = method01(10); System.out.println(sum); } public static int method01(int n){ int sum = 0; for(int i = 1;i <= n;i++){ sum += i; } return sum; } } |
使用递归实现1~n的求和。
|
public class RecursionTest03 { public static void main(String[] args){ int sum = sum(5); System.out.println(sum); } public static int sum(int n){ // 如果参数n等于1，直接返回 if(n == 1){ return 1; }else{ // 否则，将参数n减一作为参数调用自身，返回的值与参数n的和就是 // 最终的结果。 return n + sum(n - 1); } } } |
上面程序的执行流程：
练习：
1． 采用递归的方式求1~n的偶数的和。
|
public class RecursionTest04 { public static void main(String[] args){ int sum = sum(5); System.out.println(sum); } public static int sum(int n){ if(n % 2 != 0){ n -= 1; } if(n == 2){ return 2; }else{ return n + sum(n - 2); } } } |
2． 采用递归的方式求n!。
|
public class RecursionTest05 { public static void main(String[] args){ int sum = product(5); System.out.println(sum); } public static int product(int n){ if(n == 1){ return 1; }else{ return n * product(n - 1); } } } |
3． 不采用递归的方式实现n！。
|
public class RecursionTest06 { public static void main(String[] args){ int sum = product(5); System.out.println(sum); } public static int product(int n){ int product = 1; for(int i = 1;i <= n;i++){ product *= i; } return product; } } |