Java方法

1. 什么是方法？

   • 定义：所谓方法，就是用来解决一类问题的代码的有序组合，是一个功能模块。

2. 作用

   • 功能模块的复用，可以减少代码量；

3. 方法声明

   （1）语法格式：

   访问修饰符  返回类型  方法名（参数列表）{
        方法体
   }
   

   Eg: 类比我们的 main 方法

   public static void main(String[] args) {
           System.out.println("Hello,World!");
   }
   

   • 访问修饰符：指的是方法允许被访问的权限范围。main 方法中 Public 属于访问修饰符的内容。访问修饰符除了 public，还有 protect、private 等。
   • 返回类型：可以是 void 以及任何数据类型。
   • main：方法名。
   • String[] args
     • 参数列表。不是必要的，即有些方法可以没有参数列表。
     • 多个参数用逗号隔开
     • 每个参数由 参数类型和参数名 组成，类似变量的定义

   （2）注意：方法在类的内部定义！

4. 方法分类

   • 根据方法是否带参、是否返回值，可以分四类：

     • 无参无返回值方法

       • 例1：一行打印输出一串星号，效果如下图所示： 程序运行效果图.png

• 代码如下：

  public class MethorDemo {
      //打印输出星号的方法
      public void printStar(){
          System.out.println("**********************");
      }
      public static void main(String[] args) {
          //创建一个 MethodDemo 类的对象 myMethodDemo
          MethorDemo myMethorDemo = new MethorDemo();
          //使用对象名.方法名()去调用方法
          myMethorDemo.printStar();
          System.out.println("欢迎来到 Java 的世界");
          myMethorDemo.printStar();
      }
  }
  

  • 运行结果如下： 程序运行效果图2.png

• 无参带返回值方法

  • 例2 ：求长方形的面积: public int area() {}

    public class Rectangle {
        public int area() {
            int length = 10;
            int width = 5;
            int area = length * width;
            return area;
        }
    
        public static void main(String[] args) {
            Rectangle rectangle = new Rectangle();
            int area = rectangle.area();
            System.out.println("长方形的面积是"+area);
        }
    }
    

    运行结果如下：

    长方形的面积是50

  • 带参无返回值方法

    • 例3 ：定义一个求两个 float 类型数据最大值的方法，在方法中最大值打印输出

      public class MaxDemo {
          //求最大值的方法
          public void max(float a,float b) {
              float max = a > b ? a : b;
              System.out.println("两个数 "+a+" 和 "+b+" 的最大值为："+max);
          }
      
          public static void main(String[] args) {
              MaxDemo maxDemo = new MaxDemo();
              maxDemo.max(11,10);
          }
      }
      

      运行结果如下：

      两个数 11.0 和 10.0 的最大值为：11.0

  • 带参带返回值方法

    • 例4 : 定义一个求 n! 的方法，然后再求 1!+2!+3!+4!+5! : public int fac(int n) {}

      public class JieChenDemo {
          public int fac(int n) {
              int res = 1;
              for (int i = n; i > 0; i--) {
                  res = i * res;
              }
              return res;
          }
          public static void main(String[] args) {
              int sum = 0;
              JieChenDemo jieChenDemo = new JieChenDemo();
              for (int i = 1; i <= 5; i++) {
                  sum = sum + jieChenDemo.fac(i);
              }
              System.out.println("1 到 5 的阶乘和是："+ sum);
          }
      }
      

      运行结果如下：

      1 到 5 的阶乘和是：153

5. 数组作为方法参数

   • 例5：定义方法，打印输出数组元素的值：public void printArray(int[] arr) {}

     public class ArrayDemo {
         public void printArray(int[] arr) {
             for (int n: arr) {
                 System.out.print(n + "   ");
             }
         }
         public static void main(String[] args) {
             ArrayDemo arrayDemo = new ArrayDemo();
             int[] arr = {1,2,3};
             arrayDemo.printArray(arr);
         }
     }
     

     运行结果：

     1 2 3

   • 例6 ：查找数组元素的值：public boolean search(int n,int[] arr) {}

     public class SearchArrayDemo {
         public boolean search(int n,int[] arr) {
             for (int i: arr) {
                 if (i == n) {
                     return true;
                 }
             }
             return false;
         }
         public static void main(String[] args) {
             System.out.print("请输入要查找的数据：");
             Scanner scanner = new Scanner(System.in);
             int search = scanner.nextInt();
             SearchArrayDemo searchArrayDemo = new SearchArrayDemo();
             int[] arr = {10,20,30,40,50,60};
             boolean isFind = searchArrayDemo.search(search,arr);
             if (isFind) {
                 System.out.println("找到了");
             }else {
                 System.out.println("没找到");
             }
         }
     }
     

     运行结果如下：

     请输入要查找的数据：3
     没找到

6. 方法重载

   • 定义：方法名相同，参数列表不同

   • 参数列表不同既可以是参数的个数不同，也可以是参数的数据类型不同。

   • 例7 ：定义三个方法，实现 int、double 和数组类型和的问题

     public class MathDemo {
         //求两个int 类型数的和
         public int plus(int m ,int n) {
             return m + n;
         }
         //求两个double类型数的和
         public double plus(double m ,double n) {
             return m + n;
         }
         //求数组元素的累加和
         public int plus(int[] arr) {
             int sum = 0;
             for (int n: arr) {
                 sum = sum + n;
             }
             return sum;
         }
         public static void main(String[] args) {
             int[] arr = {1,2,3,4,5};
             int m = 5,n = 10;
             MathDemo mathDemo = new MathDemo();
             System.out.println("int类型的和："+ mathDemo.plus(m,n));
             System.out.println("double类型的和："+ mathDemo.plus(5.6,7.8));
             System.out.println("数组类型的累加和："+ mathDemo.plus(arr));
         }
     }
     

     运行结果如下：

     int类型的和：15
     double类型的和：13.399999999999999
     数组类型的累加和：15

7. 参数的传递问题：

• 例8 ：对两个变量的值进行交换并打印输出

  public class ExchangeDemo {
      //交换方法
      public void swap(int a,int b) {
          int temp;
          System.out.println("交换前：a="+a+",b="+b);
          temp = a;
          a = b;
          b = temp;
          System.out.println("交换后：a="+a+",b="+b);
      }
      public static void main(String[] args) {
          int m = 4,n = 5;
          ExchangeDemo exchangeDemo = new ExchangeDemo();
          System.out.println("交换前: m="+m+",n="+n);
          exchangeDemo.swap(m,n);
          System.out.println("交换前: m="+m+",n="+n);
      }
  }
  

  运行结果如下：

  交换前: m=4,n=5
  交换前：a=4,b=5
  交换后：a=5,b=4
  交换前: m=4,n=5

  Ps ：基本数据类型传值过程中，方法中的值改变并不会对主方法中的值产生影响。

8. 数组作为参数的传值问题

   • 例9 ：定义一个用于修改某个数组元素值的方法

     public class ArrayModifyDemo {
         //定义一个用于修改某个数组元素值的方法
         public void updateArray(int[] a) {
             a[3] = 15;
             System.out.println("数组a的元素为:");
             for (int n: a) {
                 System.out.print(n + "   ");
             }
             System.out.println();
         }
         public static void main(String[] args) {
             int[] a1 = {1, 2,3, 4,5};
             ArrayModifyDemo arrayModifyDemo = new ArrayModifyDemo();
             System.out.println("方法调用前数组a1的元素为：");
             for (int n: a1) {
                 System.out.print(n + "   ");
             }
             System.out.println();
             arrayModifyDemo.updateArray(a1);
             System.out.println("方法调用后数组a1的元素为：");
             for (int n: a1) {
                 System.out.print(n + "   ");
             }
         }
     }
     

     运行结果为：

     方法调用前数组a1的元素为：
     1 2 3 4 5
     数组a的元素为:
     1 2 3 15 5
     方法调用后数组a1的元素为：
     1 2 3 15 5

9. 可变参数列表

   • 例10：public void sum(int... n) {}

   public class ArgsDemo {
       //求和
       public void sum(int... n) {
           int sum = 0;
           for (int i: n) {
               sum = sum + i;
           }
           System.out.println("sum="+sum);
       }
       public static void main(String[] args) {
   
           ArgsDemo argsDemo = new ArgsDemo();
           argsDemo.sum(1);
           argsDemo.sum(1,2);
           argsDemo.sum(1,2,3);
       }
   }
   

   运行结果如下：

   sum=1
   sum=3
   sum=6

   • 例11 ：可变参数列表与数组结合使用的问题

     public class ArgsDemo1 {
         //查找
         //在方法定义中，认为当前的两个search方法重复定义，而不是重载
     //    public void search(int n,int[] a) {
     //        System.out.println("aaa");
     //    }
     
         //当参数列表有多个参数的时候，可变参数一定是放到参数列表的最后
         public void search(int n,int... a) {
             boolean flag = false;
             for (int i: a) {
                 if (i == n) {
                     flag = true;break;
                 }
             }
             if (flag) {
                 System.out.println("找到了!" + n);
             }else {
                 System.out.println("没找到" + n);
             }
         }
     
         public static void main(String[] args) {
             ArgsDemo1 argsDemo1 = new ArgsDemo1();
             argsDemo1.search(3,1,2,3,4,5);
             int[] a = {1,2,3,4,5};
             //可以将数组传递给可变参数列表，即可变参数列表兼容数组
             //反之，将可变参数列表传给数组是不允许的，程序会认为你有N个参数，需要对应定义N个参数的参数列表才行
             argsDemo1.search(3,a);
         }
     }
     

     运行结果如下：

     找到了!3
     找到了!3

     Ps：

     • 当参数列表有多个参数的时候，可变参数一定是放到参数列表的最后
     • 程序无法同时声明search(int,int...)和search(int,int[])，认为当前的两个search方法重复定义，而不是重载
     • 可以将数组传递给可变参数列表，即可变参数列表兼容数组；但是，将可变参数列表传给数组是不允许的，程序会认为你有N个参数，需要对应定义N个参数的参数列表才行。

   • 例12 ：重载的方法中，可变参数作为方法的参数，它的调用问题。

     public class ArgsDemo3 {
         public int plus(int a,int b) {
             System.out.println("不带可变参数的方法被调用!");
             return a+b;
         }
         public int plus(int... a) {
             int sum = 0;
             for (int n: a
                  ) {
                 sum = sum + n;
             }
             System.out.println("带可变参数的方法被调用!");
             return sum;
         }
     
         public static void main(String[] args) {
             ArgsDemo3 argsDemo3 = new ArgsDemo3();
             int res = argsDemo3.plus(1,2);
             System.out.println("和为"+ res);
     
         }
     

     运行结果如下：

     不带可变参数的方法被调用!
     和为3

     Ps ：

     • 可变参数列表所在的方法是最后被访问的。只要有其他重载的方法能被匹配上，参数列表带可变参数的方法就不会被执行。

10. 多行注释

* 多行注释：/*   多行注释的内容  */

* 文档注释：/** + 回车

  ~~~java
  /**
   * 关于可变参数列表和重载的问题
   * @version 1.0
   * @author linguoqun
   * 通过 javadoc 命令生成帮助文档
   */
  ~~~

• 文档注释可以在注释内容中，通过 @设置 version、author 等参数

• 可以通过 javadoc 命令生成帮助文档

  javadoc -d doc ArgsDemo1.java
  

11. 方法调试

    • 常用的几个快捷键
      • 调试过程中一步步执行（Step Over，让程序一步步执行，IDEA 快捷键 F8
      • 多断点调试的过程中，两个断点之间来回调试，而不关心两个断点之间代码的执行（Run to Cursor，Cursor 即光标，即让代码运行到光标处，IDEA 快捷键 F9）
      • 跳进方法内部去执行（Step Into，IDEA 快捷键 F7）