美文网首页
Java方法

Java方法

作者: 笔头还没烂 | 来源:发表于2023-03-27 19:29 被阅读0次
  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

  1. 数组作为方法参数

    • 例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
      没找到

  2. 方法重载

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

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

    • 例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

  3. 参数的传递问题:

  • 例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 :基本数据类型传值过程中,方法中的值改变并不会对主方法中的值产生影响。

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

    • 例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

  2. 可变参数列表

    • 例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 :

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

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

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

  ~~~java
  /**
   * 关于可变参数列表和重载的问题
   * @version 1.0
   * @author linguoqun
   * 通过 javadoc 命令生成帮助文档
   */
  ~~~
  • 文档注释可以在注释内容中,通过 @设置 version、author 等参数

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

    javadoc -d doc ArgsDemo1.java
    
  1. 方法调试

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

相关文章

  • 优秀的文章收集

    Java java8 default的用法 join方法和sleep方法 java内存模型 java-co...

  • 获取返回URL

    Java设置Cookie Java获取Cookie Js获取Cookie Java方法调用 Js方法调用

  • Java方法签名与方法块

    Java方法签名 Java的方法签名不包括返回值。 Java的方法签名包括:方法名和参数。不包括方法返回值。所以由...

  • 如何在Java中实现远程方法调用

    如何在Java中实现远程方法调用 一、Java中的远程方法调用 JAVA教程远程方法调用(Remote Metho...

  • jni常见的使用

    1. 访问java属性。 2. 访问java静态属性。 3. 访问java方法。 4. 访问java静态方法。 5...

  • java-equals方法

    equals equals 方法是 java.lang.Object 类的方法。java默认的equals方法是比...

  • Java反射

    一. Class类 二. Java动态加载类 三. Java获取方法信息 四. Java方法反射的基本操作

  • JAVA-Reflect

    一、Class类的使用 二、Java动态加载类 三、Java获取方法信息 四、Java方法的反射

  • 10.3 UiPath如何调用Java

    调用Java方法(Invoke Java Method)的介绍从Java Scope中的.jar加载的方法中调用指...

  • java收藏夹

    java中的经典问题solution Java 的静态工厂方法 单例的四种实现方法 Java中的clone方法 J...

网友评论

      本文标题:Java方法

      本文链接:https://www.haomeiwen.com/subject/jtbzrdtx.html