JavaSE03_方法

1 什么是方法

• Java方法是语句的集合，它们在一起执行一个功能
  • 方法是解决一类问题的步骤的有序组合
  • 方法包含于类或对象中
  • 方法在程序中被创建，在其他地方被引用
• 设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。在设计方法时，最好保持方法的原子性，即一个方法只完成一个功能，这样利于后期拓展
• 方法命名规则：首字母小写，驼峰规则

2 方法的定义

• Java的方法类似于其他语言中的函数，是一段用来完成特定功能的代码片段

• 方法包含一个方法头和一个方法体

  修饰符 返回值类型 方法名(参数类型 参数名) {	// 方法头
  	// 方法体
      return 返回值;
  }
  

• 一个方法中包括以下部分：

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

  • 返回值类型：方法可能会返回值，在方法名之前指定方法返回值的数据类型；有些方法没有返回值，此时返回值类型为void

  • 方法名：是方法的实际名称，方法名和参数列表共同构成方法签名

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

  • 方法体：方法体是方法中具体的语句，用于定义该方法的功能

3 方法调用

• 对于非静态方法，需要先实例化对应的类，然后通过对象名.方法名(实参列表)的方式调用

  public class Student {
      // 非静态方法
      public void say() {
          System.out.println("学生在说话");
      }
  }
  
  public class MethodTest {
      public static void main(String[] args) {
          // 需要先实例化这个类的一个对象
          Student student = new Student();
          student.say();
      }
  }
  

• 在类中通过static关键字修饰的方法为静态方法，调用静态方法时无需实例化对象，可通过类名.方法名(实参列表)调用

  public class Student {
      // 静态方法
      public static void study() {
          System.out.println("学生在学习");
      }
  }
  
  public class MethodTest {
      public static void main(String[] args) {
          // 直接通过类名调用静态方法
          Student.study();
      }
  }
  

• 静态方法是和类一起加载的，类存在时就已经存在

• 非静态方法是实例化之后才存在（对象通过new创建之后）

• 当方法有返回值时，方法调用通常被当做一个值

  int larger = max(30, 40);
  

• 如果方法的返回值为void，方法调用一定是一条语句

  System.out.println("Hello World!");
  

4 值传递与引用传递

• 形式参数：方法被调用时需要传递进来的参数，起到一个定义的作用，例如func(int a)中的a，它只有在func()被调用期间a才有意义，也就是会被分配内存空间，当方法func()执行完成后，a就会被销毁释放空间，从而不复存在

• 实参：方法被调用时传入的实际值，它在方法被调用前就已经被初始化并且在方法被调用时传入

• 值传递：在方法被调用时，实参通过形参将它的内容副本传入方法内部，此时形参接收到的内容是实参值的一个拷贝，因此在方法内对形参的任何操作，都仅仅是对这个副本的操作，不会影响原始值的内容。值传递传递的是真实内容的一个副本，对副本的操作不影响原内容，也就是说不管形参怎样变化，都不会影响实参对应的内容

• 引用传递：“引用”是指向真实内容的地址值，在方法调用时，实参的地址通过方法调用被传递给响应的形参，在方法体内，形参和实参指向同一块内存地址，对形参的操作会影响真实内容

• Java中只有值传递

• 对于基本数据类型，方法调用不会改变实参值

  public static void main(String[] args) {
      int num = 10;
      call(num);
      System.out.println(num);	// num的值仍然是10,
  }
  
  public static void call(int i) {
      i += 10;
  }
  

• 对于引用数据类型，方法调用会改变实参值

  public static void main(String[] args) {
      Person person = new Person(20, "Alice");
      call(person);
      System.out.println(person);		
      // 此时通过调用call方法，person的age和name值发生改变
  }
  
  public static void call(Person p) {
      p.setAge(40);
      p.setName("Bob");
  }
  
  class Person {
      private int age;
      private String name;
      
      public Person(int age, String name) {
          this.age = age;
          this.name = name;
      }
      
      // get、set和toString方法
  }
  

• 为什么Java只有值传递？

  从图中可以发现方法调用引用类型数据时，实际上是将引用的地址复制了一份传入方法中。由于在方法中对相同的地址进行修改，所以实参的值会被改变，但实际上还是值传递的形式

• 对于String类型，方法调用后不改变实参值

  public static void main(String[] args) {
      String str = "Hello";
      call(str);
      System.out.println(str);	// str的值仍然是Hello,
  }
  
  public static void call(String s) {
      s = "Bye";
  }
  

  在Java中，String是不可变类型，它的调用过程如下所示：

  由于String类不可变，所以在call()方法中执行s="Bye"时会新建一个String对象，并让s指向这个新建对象的地址。但是外部str指向的地址并没有改变，所以方法调用后不会改变实参的值

  Java中不可变类值用final修饰符修饰的类，对于不可变类来说，当该数据类型的对应变量的值发生变化时，其对应的内存地址也会发生变化。最常见的不可变类是String和Integer

5 方法的重载（overload）

• 重载就是在一个类中，有相同的函数名称，但形参不同的函数
• 重载的规则：
  • 方法名称必须相同
  • 参数列表必须不同（个数不同、类型不同、参数排列顺序不同）
  • 方法的返回值可以相同也可以不相同
  • 仅返回类型不同不能成为方法的重载
• 方法名和参数列表共同组成方法签名（方法签名不包括返回值），JVM凭借方法签名识别重载
• 方法名相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错，称为重载分辨
• 需要注意：
  • 构造方法也可以重载
  • 声明为final的方法不能被重载
  • 声明为static的方法不能被重载，但可以被再次声明

6 命令行传参

有时希望在运行一个程序时再传递给它消息，此时靠像main()方法传递命令行参数实现

public static void main(String[] args) {
	for (String arg : args) {
		System.out.println(arg);
	}
}

7 可变参数

• JDK5开始，Java支持传递同类型的可变参数给一个方法

• 在方法声明中，在指定参数类型后加一个省略号...

• 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何普通的参数必须在它之前声明

  public static void printMax(double... numbers) {
      if (numbers.length == 0) {
          System.out.println("No argument passed.");
          return;
      }
      
      double result = numbers[0];
      
      // 找最大值
      for (int i = 1; i < numbers.length; i++) {
          if (numbers[i] > result) {
              result = numbers[i];
          }
      }
      
      System.out.println("The max value is " + result);
  }
  

• 调用可变参数的方法：

  printMax(5, 2, 3, 4, 7, 1);				// 直接调用
  printMax(new double[]{1, 2, 3, 4});		// 通过数组调用
  

8 递归

• 递归就是方法调用自身
• 利用递归可以用简单的程序来解决一些复杂的问题，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大减少了程序的代码量，递归的能力在于用有限的语句定义对象的无限集合
• 递归结构包括
  • 递归头：什么时候不调用自身方法，如果没有递归头，将陷入死循环
  • 递归体：什么时候需要调用自身方法
• 递归本质是不断循环调用自身，则需要不停进行入栈操作，如果循环次数过大，会造成空间不足的问题