Java学习笔记 07 - 关于方法

一、Java中的方法

1、方法的概念

在Java中，从面向对象的哲学来说，方法是对象所具有的行为。就方法本身来说，方法是完成特定功能的、相对独立的程序段，与其它编程语言中的子程序、函数等概念相当。方法一旦声明，可以在不同的程序段中多次调用。

在之前的内容中已经使用过多次由JDK提供的方法，如：

System.out.println("Hello World"); 		// println() 是一个方法
new Random().nextInt();					// nextInt() 是一个方法
"Hello World".length();					// length() 是一个方法

2、为什么使用方法

通过使用方法，可以：

• 实现对象的行为，使程序符合面向对象的哲学。
• 使程序变得更简短而清晰。
• 提高了代码的重用性。
• 可以提高程序开发的效率。
• 有利于程序维护。

二、方法的声明

Java中，声明一个方法的语法如下：

[修饰符] 返回值类型 方法名称([参数列表]) {
	// 方法体
}

说明：

• 声明方法的语句中包括方法头（方法声明）和方法体两部分。其中方法头（方法声明）确定方法的名称，形式参数的名称、类型和顺序，返回值的类型和方法的访问权限。方法体由括在花括号内的语句组成，这些语句实现方法的功能。
• 方法的修饰符是可选的，最常用的修饰符是public，表示方法是公开的。
• 返回值类型反映方法完成其功能后返回的运算结果的数据类型。如果方法没有返回值，使用void关键字声明。
• 方法名称符合标识符命名规范，并遵守约定，使用动词或动宾短语，见名知意，符合驼峰式命名法。
• 方法的参数列表指定在调用该方法时，应该传递的参数的顺序、个数和数据类型。参数列表中可以包含若干个参数（没有、一个或多个），相邻的两个参数之间用逗号（,）隔开。
• 方法声明中的方法头（方法声明），对于调用方法的开发者来说，便可以认为是API，即应用程序编程接口。

/**
 * 方法声明
 *
 * @author DingYi
 * @date 2020/3/27 19:08
 */
public class MathUtils {
  /**
   * 将两个整数相乘并打印结果
   * @param num1 第一个参与相乘的整数
   * @param num2 第二个参与相乘的整数
   */
  public void multipiyAndPrint(int num1,int num2){
    int result = num1 * num2;
    System.out.printf("%d与%d相乘的结果是%d\n",num1,num2, result);
  }

  /**
   * 将两个整数相加并返回结果
   * @param num1 第一个参与相加的整数
   * @param num2 第二个参与相加的整数
   * @return 相加的结果
   */
  public int add(int num1, int num2){
    return num1 + num2;
  }
}

说明：

• 该示例中声明了一个类，名叫MathUtils，该类中声明了两个方法。
• multiplyAndPrint(int num1, int num2)方法可以将两个整数相乘并打印结果。
• add(int num1, int num2)方法可以将两个整数相加并返回结果，注意该方法中的return语句，对于有返回值的方法，方法体中通过return语句来返回值，详细内容将在后面的内容中介绍。

三、方法的调用

调用方法，即执行该方法。发出调用的方法称为主调方法，被调用的方法称为被调方法。方法调用一般情况下由对象使用.操作符完成，语法格式如下：

对象.方法名([参数1, 参数2, ..., 参数n]);

• 实例：

/**
 * 测试类
 *
 * @author DingYi
 * @date 2020/3/27 19:17
 */
public class Test {
  public static void main(String[] args) {
    //实例化一个MathUtil类的对象，并赋值给MathUtils类型的变量mu
    MathUtils mu = new MathUtils();
    // 通过mu调用multiplyAndPrint(int num1, int num2)方法
    mu.multipiyAndPrint(2,3);
    // 通过mu调用add(int num1, int num2)方法，并赋值给变量result
    int result = mu.add(1,2);
    // 打印result
    System.out.println("result = " + result);
  }
}

四、方法的返回值

方法的返回值即被调方法在调用后返回给主调方法的数据。大多数情况下，方法被调用后都需要告诉主调方法运算或处理的结果，此时便需要方法的返回值。
通常方法的设计应当遵循功能单一的原则，即一个方法只做一件简单而明确的事，像前面例子中的multiplyAndPrint(int num1, int num2)方法，即包含了进行相乘运算的功能，也包含了打印结果的功能，违背了方法功能单一的原则。更好的方式应该将打印结果的功能从该方法中移除，将结果返回，交由主调方法去处理。

• 修改后的MathUtils类源码：

/**
 * 方法声明
 *
 * @author DingYi
 * @date 2020/3/27 19:20
 */
public class MathUtils {
  /**
   * 将两个整数相乘并返回结果
   * @param num1 第一个参与相乘的整数
   * @param num2 第二个参与相乘的整数
   * @return 相乘的结果
   */
  public int multiply(int num1, int num2) {
    int result = num1 * num2;
    return result;
  }

  /**
   * 将两个整数相加并返回结果
   * @param num1 第一个参与相加的整数
   * @param num2 第二个参与相加的整数
   * @return 相加的结果
   */
  public int add(int num1, int num2) {
    return num1 + num2;
  }
}

说明：

• 方法需要向主调方法返回值时，方法声明中要明确返回值类型，方法体中通过return语句来返回值，语法格式如下：

return [表达式];

• 当调用方法时，方法的返回值就是return后面的表达式的值。返回值的类型必须与方法声明的返回值类型一致。
• 被调方法只能给主调方法返回一次数据。
• 在方法执行过程中，一旦执行了return语句，方法结束执行并返回。
• 在返回值类型声明为void的方法中，可以使用return;结束方法执行。

五、方法的参数

1、方法传参

方法的参数即调用方法时主调方法依据被调方法声明的参数列表传递给被调方法的数据。调用方法时，主调方法中传入的参数称之为实际参数（实参），被调方法中用来接收数据的参数称之为形式参数（形参）。通常在设计方法时，将方法被调用时会变化的数据设计成方法的参数，可以使方法更加灵活的根据调用者的需要进行处理。

• 修改后的MathUtils类源码：

/**
 * 方法声明
 *
 * @author DingYi
 * @date 2020/3/27 19:20
 */
public class MathUtils {
  /**
   * 将两个整数相乘并返回结果
   * @param num1 第一个参与相乘的整数
   * @param num2 第二个参与相乘的整数
   * @return 相乘的结果
   */
  public int multiply(int num1, int num2) {
    int result = num1 * num2;
    return result;
  }

  /**
   * 将两个整数相加并返回结果
   * @param num1 第一个参与相加的整数
   * @param num2 第二个参与相加的整数
   * @return 相加的结果
   */
  public int add(int num1, int num2) {
    return num1 + num2;
  }
  public int getGCD(int num1, int num2){
    while(true){
      if(num1 < num2){
        int temp = num1;
        num1 = num2;
        num2 = temp;
      }
      int remainder = num1 % num2;
      if(remainder == 0){
        return num2;
      }else {
        num1 = num2;
        num2 = remainder;
      }
    }
  }
}

• Test类源码：

/**
 * 测试类
 *
 * @author DingYi
 * @date 2020/3/27 19:17
 */
public class Test {
  public static void main(String[] args) {
    // 实例化一个MathUtils类的对象，并赋值给MathUtils类型的变量mu
    MathUtils mu = new MathUtils();

    // 定义两个int类型的变量number1和number2，分别存储数字319和377
    int number1 = 319, number2 = 377;

    // 通过mu调用add(int num1, int num2)方法，并赋值给变量sum
    // 注意方法传参时，实参的顺序、类型、数量均要与方法的参数列表相同
    int sum = mu.add(number1, number2);
    // 打印sum
    System.out.println("sum = " + sum);

    // 通过mu调用getGCD(int num1, int num2)方法，并赋值给变量gcd
    // 注意方法传参时，实参的顺序、类型、数量均要与方法的参数列表相同
    int gcd = mu.getGCD(number1, number2);
    // 打印gcd
    System.out.println("gcd = " + gcd);
  }
}

说明：

• MathUtils类中新声明了方法getGCD(int num1, int num2)，用来计算两个整数的最大公约数（Greatest Common Divisor），使用了辗转相除法。
• Test类的main()方法中实例化一个MathUtils类的对象，并赋值给MathUtils类型的变量mu，通过mu调用了add(int num1, int num2)和getGCD(int num1, int num2)，方法传参时，实参的顺序、数据类型、数量均要与方法的参数列表相同。
• 另外，当被调用的方法不需要传参数时，方法声明时和调用时方法名后的()不能省略。参数列表的设计要根据实际情况来定，参数太多，调用不便；参数太少，方法不灵活。

2、方法传参时基本数据类型和引用数据类型的内存变化

• 参数有形参和实参，定义方法时写的参数叫形参，真正调用方法时，传递的参数叫实参。调用方法时，会把实参传递给形参，方法内部其实是在使用形参。

1. 所谓值传递就是当参数是基本类型时，传递参数的值，比如传递i=10，真实传参时，把10赋值给了形参。
2. 当参数是对象时，传递的是对象的值，也就是对象的首地址。就是把对象的地址赋值给形参

• 基本数据类型和引用数据类型作为参数的区别
  基本数据类型的变量中直接存放数据值本身，所以改的时候改的是数据值本身；但是引用类型不同的地方在于真正的数据并没有在栈区的变量中保存，而是在堆区里面保存着，所以虽然也拷贝了一份，也是副本，但是二者指向的是同一块堆区。引用数据类型就好比如说，两位同学使用的是同一份复习资料，其中一人把资料撕毁了，另一人当然也会受到影响。而基本数据类型就好比复印了一份，其中一人将自己的资料撕了，并不影响别人。

• 总结：

1. 当使用基本数据类型作为方法的形参时，在方法体中对形参的修改不会影响到实参的数值。
2. 当使用引用数据类型作为方法的形参时，若在方法体中修改形参指向的数据内容，则会对实参变量的数值产生影响，因为形参变量和实参变量共享同一块堆区。
3. 当使用引用数据类型作为方法的形参时，若在方法体中修改形参变量的指向，此时不会对实参变量的数值产生影响，因为形参变量和实参变量分别指向不同的堆区；

3、方法的可变参数

设计方法时，如果参数的类型可以确定，但个数不确定，可以使用可变参数。

• 修改后的MathUtils类部分源码：

/**
 * 方法声明
 *
 * @author DingYi
 * @date 2020/3/27 19:20
 */
public class MathUtils {
  /**
   * 将若干个整数相加并返回结果
   * @param nums 参与相加的整数，可变数组
   * @return 相加的结果
   */
  public int add(int ... nums){
    int sum = 0;
    //参数nums是一个int类型的数组
    if(nums instanceof int[]){
      System.out.println("nums是一个int型的数组");
    }
    //循环累加
    for(int num : nums){
      sum += num;
    }
    return sum;
  }
}

• Test类源码：

/**
 * 测试类
 *
 * @author DingYi
 * @date 2020/3/27 19:17
 */
public class Test {
  public static void main(String[] args) {
    // 实例化一个MathUtils类的对象，并赋值给MathUtils类型的变量mu
    MathUtils mu = new MathUtils();
    // 通过mu调用add(int ... nums)方法，累加若干个整数并返回结果
	// 该方法声明时使用了可变参数，传参时参数的个数不受限制
  	int sum1 = mu.add(1,5,6,9,8,7,4,5);
    System.out.println("sum1 = " + sum1);

    //可变参数其实就是数组
    int[] nums = {3,6,9,8,7,4,5};
    int sum2 = mu.add(nums);
    System.out.println("sum2 = " + sum2);
  }
}

说明：

• 可变参数其实就是数组。上例中instanceof运算符用来判断对象是否是特定类的一个实例。
• 参数列表中只能有一项可变参数，且必须位于参数列表的最后。

六、方法的重载

在一个类中，多个方法具有相同的方法名称，但却具有不同的参数列表，与返回值无关，称作方法重载（overload）。

• 修改后的MathUtils类部分源码：

/**
 * 方法声明
 *
 * @author DingYi
 * @date 2020/3/27 19:20
 */
public class MathUtils {
  /**
   * 将两个整数相乘并返回结果
   * @param num1 参与相乘的第一个整数
   * @param num2 参与相乘的第二个整数
   * @return
   */
 public int multiply(int num1, int num2){
   return num1 * num2;
 }

  /**
   * 将两个浮点数相乘并返回结果
   * @param num1 第一个参与相乘的浮点数
   * @param num2 第二个参与相乘的浮点数
   * @return
   */
 public double multiply(double num1, double num2){
   return num1 * num2;
 }

  /**
   * 将两个整数相加并返回结果
   * @param num1 参与相加的第一个是整数
   * @param num2 参与相加的第二个整数
   * @return
   */
 public int add(int num1, int num2){
   return num1 + num2;
 }

  /**
   * 将两个浮点数相加并返回结果
   * @param num1 参与相加的第一个浮点数
   * @param num2 参与相加的第二个浮点数
   * @return
   */
 public double add(double num1,double num2){
   return num1 + num2;
 }
}

• Test类源码：

/**
 * 测试类
 *
 * @author DingYi
 * @date 2020/3/27 19:17
 */
public class Test {
  public static void main(String[] args) {
    // 实例化一个MathUtils类的对象，并赋值给MathUtils类型的变量mu
    MathUtils mu = new MathUtils();

    // 调用multiply(int num1, int num2)方法
    int result1 = mu.multiply(3, 4);
    System.out.println("result1 = " + result1);

    // 调用multiply(double num1, double num2)方法
    double result2 = mu.multiply(3.14, 6.18);
    System.out.println("result2 = " + result2);

    // 调用add(int num1, int num2)方法
    int result3 = mu.add(3,4);
    System.out.println("result3 = " + result3);

    // 调用add(double num1, double num2)方法
    double result4 = mu.add(3.12, 6.18);
    System.out.println("result4 = " + result4);
  }
}

说明：

• 参数列表不同，是指参数个数、参数数据类型，参数顺序不同。比如以下是正确的方法重载的例子：

public double area(double a);
public double area(int a, double b);
public double area(double a, int b);

而以下是错误的方法重载的例子：

public int calc(int a, int b);
public void calc(int x, int y);

• 两个calc()方法虽然返回值类型和参数名称不同，但参数个数、类型和顺序完全相同，也就是说它们的参数列表是相同的。
• 调用方法时，方法名和传入的参数共同决定了具体调用了哪个方法。
• JDK API中有众多方法重载的例子，比如String类的substring([参数])、indexOf([参数])、lastIndexOf([参数])方法，PrintStream类的println()方法等。

七、构造方法

类中有一种特殊的方法，其方法名与类名相同，没有返回值类型，这种方法叫构造方法，也叫构造函数或构造器。

• 实例：

/**
 * 构造方法
 *
 * @author DingYi
 * @date 2020/3/27 21:28
 */
public class Student {
  //声明成员变量
  String name;   //姓名
  int age;        //年龄
  String studentNo;//学号
  
  public Student(){
    System.out.println("Student类无参数的构造方法被调用" );
  }
  //有一个参数的构造方法
  public Student(String name){
    this.name = name;
    System.out.println("Student类含有参数name的构造方法被调用");
  }
  //有三个参数的构造方法
  public Student(String name, int age, String studentNo) {
    this.name = name;
    this.age = age;
    this.studentNo = studentNo;
  }
  //自我介绍
  viod introduce(){
    System.out.printf("大家好，我是%s，我今年%d岁，我的学号是：%s",name,age,studentNo);
  }
}

说明：

• 构造方法主要用来在创建对象时为对象的成员变量赋初始值。
• 构造方法不允许使用对象调用，只有在用new运算符实例化对象时才会被自动调用。
• 如果类中不显示声明构造方法，系统会为类默认提供无参数的构造方法。如果自定义了构造方法，系统默认的构造方法就不存在了。
• 一个类可以声明多个构造方法，即构造方法的重载，满足方法重载的要求即可。
• 上例中使用了this关键字，在Java中，this可以引用当前类的对象。

八、变量的作用域和生命周期

1、变量的作用域

• 变量的作用域就是指一个变量定义后，在程序的什么地方能够使用。

• 在Java中，一对大括号 { } 包含的区域，也被称之为一个代码块（语句块）。使用大括号{ }的地方有：类声明、方法声明、方法中的循环体、分支条件后的语句等，一个变量的作用域只被限制在该变量声明所在的代码块中（也就是离该变量的声明语句最近的大括号内）。

• 方法中声明的变量，称为局部变量，方法的形式参数也是方法的局部变量。局部变量只能在当前方法中使用；在判断代码块中声明的变量只能在当前判断代码块中使用，当前判断代码块之外不能正常使用；对循环代码块也是一样。

• 声明在类中，但在方法之外的变量称为成员变量。被static关键字修饰的成员变量在整个类声明里的成员方法中都可以使用；没有被static关键字修饰的成员变量在整个类声明里没有被static关键字修饰的成员方法中都可以使用。有时在一个方法中，会遇到局部变量和成员变量同名的情况，此时，直接使用变量名其实是在使用局部变量，如果要使用成员变量，需要this.成员变量名。

2、变量的生命周期

• 变量的生命周期是指变量什么时候分配内存，什么时候从内存中回收。

• 对于局部变量，会在方法或语句块执行的时候创建（在栈中分配内存），当它们执行完成后，变量随之被销毁。另外，局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

• 对于没有被static关键字修饰的成员变量，会在对象创建的时候创建，在对象被销毁的时候销毁（在堆中分配内存）。另外，成员变量在创建时具有默认值，数值型变量的默认值是0（整型是0，浮点型是0.0），字符型变量的默认值是'\u0000'，布尔型变量的默认值是false，引用类型变量的默认值是null。