什么是方法
用来解决一类问题的代码的有序组合，是一个功能模块

方法声明

语法格式：
访问修饰符 返回类型 方法名(参数列表){
方法体
}

  1. public class HelloImooc {
  2.     // 方法声明
  3.     public static void main(String[] args) {
  4.         // 方法体
  5.     }
  6. }

方法调用

在main函数中调用方法，需要先创建类对象，然后调用对象的方法

  1. package com.imooc;
  3. public class HelloImooc {
  4.     // 输出打印星号的方法
  5.     public void printStar() {
  6.         System.out.println("**********");
  7.     }
  9.     public static void main(String[] args) {
  10.         // 创建一个HelloImooc类的对象myHelloImooc
  11.         HelloImooc myHelloImooc = new HelloImooc();
  12.         // 使用对象名.方法名()去调用方法
  13.         myHelloImooc.printStar();
  14.         System.out.println("hello java");
  15.         myHelloImooc.printStar();
  16.     }
  17. }

在其他函数中，可以直接调用方法

  1. package com.imooc;
  3. public class HelloImooc {
  4.     public void printStar() {
  5.         System.out.println("**********");
  6.     }
  8.     public void printTest() {
  9.         printStar();
  10.         System.out.println("hello java");
  11.         printStar();
  12.     }
  14.     public static void main(String[] args) {
  15.         HelloImooc myHelloImooc = new HelloImooc();
  16.         myHelloImooc.printTest();
  17.     }
  18. }

方法重载

方法名相同，参数列表不同（可以是数量不同，也可以是数据类型不同）
#注意返回值不同，不是重载

  1. package com.imooc;
  3. public class HelloImooc {
  4.     // 求两个int类型数的和
  5.     public int plus(int m, int n) {
  6.         return m + n;
  7.     }
  9.     // 求两个double类型数的和
  10.     public double plus(double m, double n) {
  11.         return m + n;
  12.     }
  14.     // 求数组元素的和
  15.     public int plus(int[] arr) {
  16.         int sum = 0;
  17.         for (int n : arr) {
  18.             sum += n;
  19.         }
  20.         return sum;
  21.     }
  23.     public static void main(String[] args) {
  24.         HelloImooc hl = new HelloImooc();
  26.         System.out.println(hl.plus(5, 6));        // 11
  27.         System.out.println(hl.plus(5.2, 6.3));    // 11.5
  29.         int[] arr = { 1, 2, 3, 4, 5, 6 };
  30.         System.out.println(hl.plus(arr));        // 21
  31.     }
  32. }

参数传递

1，值传递：传递基本类型数据
值传递不会改变原来的参数的值

  1. package com.imooc;
  3. public class HelloImooc {
  4.     // 更新数组
  5.     public void updateNum(int num) {
  6.         num++;
  7.         System.out.println("被调用函数中的值："+num);    // 被调用函数中的值：11
  8.     }
  11.     public static void main(String[] args) {
  12.         int num = 10;
  14.         HelloImooc myHelloImooc = new HelloImooc();
  15.         myHelloImooc.updateNum(num);
  17.         System.out.println("主函数中的值："+num);    // 主函数中的值：10
  18.     }
  19. }

2，地址传递：传递引用类型数据（比如数组，对象）
地址传递可能改变原来的参数的值

  1. package com.imooc;
  3. public class HelloImooc {
  4.     // 更新数组
  5.     public void updateArray(int[] arr) {
  6.         arr[3] = 15;
  7.     }
  9.     // 打印数组
  10.     public void printArray(int[] arr) {
  11.         for (int n : arr) {
  12.             System.out.print(n + " ");
  13.         }
  14.         System.out.println();
  15.     }
  17.     public static void main(String[] args) {
  18.         int[] arr = { 1, 2, 3, 4, 5, 6 };
  19.         HelloImooc myHelloImooc = new HelloImooc();
  21.         myHelloImooc.printArray(arr);    // 1 2 3 4 5 6
  22.         myHelloImooc.updateArray(arr);
  23.         myHelloImooc.printArray(arr);    // 1 2 3 15 5 6 
  24.     }
  25. }

可变参数

  • 可变参数与数组类似，可以用增强for循环取值
  • 参数列表中如果有两个以上的参数，可变参数一定是放在最后的
  • 一个方法中只能有一个可变参数
  • 可以将数组传递给可变参数列表
  • 可变参数列表所在的方法是最后被访问的 ```java package com.imooc;

public class HelloImooc { // 求和 public void sum(int… n) { int sum = 0; for (int i : n) { sum += i; } System.out.println(“sum=” + sum); }

  1. public static void main(String[] args) {
  2.     HelloImooc myHelloImooc = new HelloImooc();
  4.     myHelloImooc.sum(1);        // sum=1
  5.     myHelloImooc.sum(1, 2);        // sum=3
  6.     myHelloImooc.sum(1, 2, 3);    // sum=6
  8.     int[] a = { 10, 20, 30 };
  9.     myHelloImooc.sum(a);        // sum=60
  10. }

} ```