Java方法

方法介绍

方法是一段可重复调用的代码段（语句的集合，它们在一起执行一个功能）。

1）方法是解决一类问题的步骤的有序组合

2）方法包含于类或对象中

3）方法在程序中被创建，在其他地方被引用

方法有哪些优点？

1）使程序变得更简短而清晰。

2）有利于程序维护。

3）可以提高程序开发的效率。

4）提高了代码的重用性（用于封装代码）。

 

方法的命名规则：

1）方法的名字首先要满足作为标识符的要求，还有就是它的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符。例如：addUser。

2）下划线可能出现在 JUnit 测试方法名称中用以分隔名称的逻辑组件。一个典型的模式是：test<MethodUnderTest>_<state>，例如 testPop_emptyStack。

 

方法的定义

方法其实就是一个功能，定义方法就是实现功能，通过两个明确来完成：

1）明确该功能的运算完的结果，其实是在明确这个方法的返回值类型。

2）在实现该功能的过程中是否有未知内容参与了运算，其实就是在明确这个方法的参数列表(参数类型&参数个数)。

方法的定义格式：

修饰符 返回值类型 方法名(参数类型 形式参数1，参数类型 形式参数1，…) // 方法头
{   // 方法体
    执行语句；
    return 返回值； // 如果方法的返回值类型是void，return语句可以省略不写，系统会帮你自动加上
}

下面我们来看一下方法定义的各个部分：

修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。

返回值类型 ：方法可能会有返回值，所以需要表明方法返回值的数据类型。当方法没有具体的返回值时，返回的返回值类型用void关键字表示。

方法名：是方法的实际名称，方法名和参数表共同构成方法签名。合适的方法名可以对对方法功能进行标示，明确方法的功能，增加代码的阅读性，方便于调用。

参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

方法体：方法体包含具体的语句，定义该方法的功能。

return语句：return语句一般在方法体内，作用是返回方法执行时的结果，并结束方法、结束功能。如果方法的返回值类型是void时，return语句可以省略不写的，系统会帮你自动加上。

下面我们举个例子来看一下：

/** 返回两个整型变量数据的较大值 */
public static int maxNum(int num1, int num2) {
   int result;
   if (num1 > num2)  // 当整个分支结构每个分支最多只有一条语句时，花括号可以省略
      result = num1;
   else    
      result = num2; 
   return result; 
}
/** 返回值为void 的方法 */
public static void printName(String name) {
    System.out.println(name);
}

 

方法的调用

Java 支持两种调用方法的方式，根据方法是否返回值来选择。

当程序调用一个方法时，程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。

当方法返回一个值的时候，方法调用通常被当做一个值。例如：

int maxResult = maxNum(10, 20); 

如果方法返回值是void，方法调用一定是一条语句。例如下面的调用是个语句：

printName("爪哇菌");

注意：

1）方法中只能调用方法，不能定义方法。

2）方法只有被调用才会被执行。

3）定义方法时，方法的结果应该返回给调用者，交由调用者处理。

4）main 方法是被 JVM 调用的，除此之外，main 方法和其它方法没什么区别。

 

方法的参数专递

方法必须有其所在类或对象调用才有意义。方法含有参数：

形参：方法声明时的参数

实参：方法调用时实际传给形参的参数值

 

调用一个方法时候需要提供参数，你必须按照参数列表指定的顺序提供。

Java的实参值如何传入方法呢？Java里方法的参数传递方式只有一种：值传递。  即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

关于Java中方法传参为什么是值传递而不是引用传递的问题我们将在其他篇章去详细说明，这里就不详细赘述了。下面我们来看着Java方法传参的示例：

public class Test {
  public static void main(String[] args) {
    int num1 = 1;
    int num2 = 2; 
    System.out.println("调用前 num1：" + num1 + " ，num2：" + num2); //(1) 1,2
    swap(num1, num2);
    // 传递两个参数调用swap方法。有趣的是，方法被调用后，实参的值并没有改变。
    System.out.println("交换后 num1：" + num1 + " ，num2：" + num2); //(4) 1,2
  }
  /** 交换两个变量的方法 */
  public static void swap(int n1, int n2) {
    System.out.println("交换前 n1：" + n1 + "，n2：" + n2); //(2) 1,2
    // 交换 n1 与 n2的值
    int temp = n1;
    n1 = n2;
    n2 = temp;
    System.out.println("交换后 n1：" + n1 + "，n2：" + n2); //(3) 2,1
  }
}

 

方法的重载

方法的重载：就是在一个类中方法名称相同，但参数的类型和参数的个数至少有一个不同，通过传递参数的个数及类型不同以完成不同功能的方法调用。

如何区分重载？当函数同名时，只看参数列表，和返回值类型没关系。

public class Test {
    public static void main(String[] args) {
        int one = add(10, 20); // 调用有两个参数的整型加法
        int two = add(10, 20, 30); // 调用有三个参数的整型加法
        float three = add(10.3f, 13.3f); // 调用有两个参数的浮点型加法
        System.out.println("add(int x, int y)的计算结果：" + one) ;
        System.out.println("add(int x, int y, int z)的计算结果：" + two);
        System.out.println("add(float x, float y)的计算结果：" + three);
    }
    public static int add(int x, int y) { // 定义add方法，完成两个整数相加
        int temp = 0; // 定义局部变量
        temp = x + y; // 执行加法计算
        return temp; // 返回计算结果
    }
    public static int add(int x, int y, int z) { // 定义add方法，完成三个整数相加
        return x + y + z; // 返回计算结果
	}
    public static float add(float x, float y) { // 定义add方法，完成两个浮点数相加
        return x + y; // 返回计算结果
    }
}

执行结果如下：

add(int x, int y)的计算结果：30
add(int x, int y, int z)的计算结果：60
add(float x, float y)的计算结果：23.6

从程序中可以发现add()方法被重载了三次，而且每次重载时的参数类型或个数都有不同，所以在调用的时候，会根据参数的类型和个数自动进行区分。

屏幕打印语句System.out.println()方法也属于重载方法可以打印很多类型的数据：

System.out.println(6); // 输出整数
System.out.println(66.6); // 输出浮点数
System.out.println('6'); // 输出字符
System.out.println(true); // 输出布尔型
System.out.println(3 + 3); // 输出计算结果

 

方法的递归

递归调用是一种特殊的调用形式，是方法自己调用自己。

对于一个复杂的问题，把原问题分解为若干个相对简单类同的子问题，继续下去直到子问题简单到能够直接求解，也就是说到了递推的出口，这样原问题就有递推得解。 

实现递归的三要素： 1）方法中自己调用自己  2）要有分支    3）要有结束条件

递归是一种常见的解决问题的方法，寄把问题逐渐简单化。递归的基本思想就是“自己调用自己”，一个使用递归技术的方法会直接或间接的调用自己。

递归构造包括两个部分：

定义递归头：什么时候不调用自身方法，如果没有头，将陷入死循环

递归体：什么时候需要调用自身方法

斐波那契数列：

/** 1  1  2  3  5  8  13  21  34  55 ...  斐波那契数列 */
public class Test {
	public static void main(String[] args) {
        int n = 100;
        for(int i = 1; i <= n; i++){
            System.out.print(printNum(i) + " ");
        }
    }
    //使用递归获得数列中第i个数的值
    private static long printNum(int i){
        if(i == 1 || i == 2){
        	return 1;
        }else{
            return printNum(i-1) + printNum(i-2);
        }
    }
}

 

命令行参数的使用

有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main()函数实现。

命令行参数是在执行程序时候紧跟在程序名字后面的信息，多个参数用空格分隔，如果参数本身包含空格，则需要用双引号（""）引起来。下面来看个示例：

public class Test{
   public static void main(String args[]){ 
      for(int i=0; i<args.length; i++){
         System.out.println("args[" + i + "]: " + args[i]);
      }
   }
}

我们来运行这个程序看下结果：

$ javac Test.java 
$ java Test this is a "com mand" line
args[0]: this
args[1]: is
args[2]: a
args[3]: com mand
args[4]: line

 

相关文章：

Java方法的参数传递

Java数组传递及可变参数