JavaSE从零学起10. Java方法详解：方法重载、命令行传参、不定项参数-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_45161329/article/details/117485600

Java方法详解：方法重载、命令行传参、不定项参数

文章目录

Java方法详解：方法重载、命令行传参、不定项参数

何谓方法？

大家对System.out.println（）一定不陌生，那么你真的知道它是什么吗？

System是java.lang里面的一个类，out是System类中的一个静态数据成员，而且这个成员是java.io.PrintStream类的引用。System.out是调用了System类的静态数据成员out。 println()就是java.io.PrintStream类里的一个方法，它的作用是向控制台输出信息。因为System.out是java.io.PrintStream类的实例的引用，所以可以通过 System.out.println(); 来调用此方法。
Java方法是语句的集合，它们在一起执行一个功能。
1. 方法是解决一类问题的步骤的有序组合。
2. 方法包含于类或对象中
3. 方法在程序中被创建，在其他地方被引用
设计方法的原则：方法的本意是功能块，即实现某个功能的语句块的集合。我们设计方法的时候最好保持方法的原子性：一个方法只完成一个功能，这样有利于我们后期的扩展。
方法的命名规则：首字母小写，后面遵循驼峰命名法。

下面看个调用方法的简单例子。

public class Demo01 {
    public static void main(String[] args) {
        //1,2是实际参数：实际调用方法时传递给它的参数
        int sum = add(1,2);//把add方法输出的结果赋值给sun
        System.out.println(sum);//输出sun
        System.out.println("==============");
        print();//调用了print方法
    }
    /*public static int add()中的Int是设置了该方法的返回值类型必须为int类型 */
    //a和b是两个形式参数，用于定义作用。
    public static int add(int a,int b) {
        return a+b;
    }
    
 /*void是设置了该方法无返回值，因为方法中已经用了System.out.println()进行输出*/
    public static void print() {
        for (int i = 1; i < 10; i++) {
            for(int j = 1; j<=i ;j++){
                System.out.print(j+"*"+i +"=" + (i*j) +" ");
            }
            System.out.println();
        }
    }
}

输出结果：
3
==============
1*1=1 
1*2=2 2*2=4 
1*3=3 2*3=6 3*3=9 
1*4=4 2*4=8 3*4=12 4*4=16 
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

方法的定义

Java方法类似于其它编程语言的函数。是一段用来完成特定功能的代码片段。

一个方法包含一个方法头和一个方法体。一般情况下一个方法包含下列语法：

修饰符 返回值类型 方法名（参数类型 参数名）{
...
方法体
...
return 返回值；
}

修饰符：可选部分。定义了该方法的访问类型，告诉编译器如何调用该方法。
返回值类型: 方法可能会返回值。返回值类型（returnValueType）是方法返回值的数据类型。有些方法执行了操作但是没有返回任何值。这种情况下返回值类型是关键字void。
方法名：方法的实际名称，方法名和参数表共同构成方法签名。
参数类型：参数就像一个占位符，当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数个数。参数是可选的，方法可以不包含任何参数。
- 形式参数：在方法被调用时用于接收外界输入的数据。
- 实参：调用方法时实际传给方法的数据
方法体：方法体包含具体的语句，定义了该方法的功能。

public static void main(String[] args) {
        //实际参数：实际调用方法时传递给它的参数
        int sum = add(1,2);
    }
    //a和b是两个形式参数，用于定义作用。
    public static int add(int a,int b) {
        return a+b;
    }

方法的调用

调用方法：对象名.方法名（实参列表）
关于具体的静态方法和非静态方法调用静态变量与非静态变量之间的比较，可以参见我另一篇blog。Java变量与方法的调用_Clap of thunder的博客-优快云博客
Java方法支持两种调用方法的方式，根据方法是否返回值来选择。

方法调用流程

当方法返回一个值的时候，方法调用通常被当做一个值。例如：
```
int max = max(20,10);
```
无返回值的方法：一个方法去执行一些操作，但是最终没有把处理的结果返回给调用者，只是执行了这个方法的代码块。
没有返回值的方法只能单独调用，切忌打印输出：sout(methodName())

访问修饰符 void 方法名（参数）{
- 方法体
- //return,可写可不写，一般不写
- }

下面我们看一个比大小的方法来体会一下方法的两种调用方式：

public class Demo02 {
    /*比大小的方法*/
    public static void main(String[] args) {
        int max = max(20,10);
        System.out.println(max);

        printStar();//单独调用
        System.out.println("=============");

        printStarCount(5);//单独调用
                          //指定输出*数量为5
    }

    public static int max(int num1, int num2) {

        int result = 0;
        if(num1 > num2){
            result = num1;
        }else if (num1 < num2){
            result = num2;
        }else {
            return 0;//终止方法
        }
        return result;
    }

    /*该方法只是执行了一段代码。不需要任何条件自己就能完成任务。
    所以也不用参数，参数留空*/
    public static void printStar(){//没有结果数产生，不用返回数。
        for (int i = 0; i < 10; i++) {
            System.out.print("*"+" ");
        }
        System.out.println();
    }

    //按照要求输出指定数量的*
    //参数列表：需要知道具体指定数量，需要指定一个int参数
    public static void printStarCount(int count){
        for (int i = 0; i < count; i++) {
            System.out.print("*"+" ");
        }
    }
}

输出结果：
20
* * * * * * * * * * 
=============
* * * * *

方法重载（overload）

重载就是在一个类中有相同的函数名称但是形参不同的函数。

方法重载的规则

方法名必须相同。
参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。
方法的返回类型可以相同也可以不同。
仅仅返回类型不同不足以成为方法的重载。

实现理论：

方法名称相同时，编译器会根据调用方法的参数个数、参数类型去逐个匹配，以选择对应的方法，如果匹配失败则编译器报错。

下面我们来看add（）方法的重载实例：

public class OverLoadDemo {
        public static void main(String[] args) {
            int sum = add(1,2);
            System.out.println(sum);
            System.out.println("==============");

            //与上一个方法不同的是参数列表有三个
            int sum1 = add(1,2,3);
            System.out.println(sum1);
            System.out.println("==============");

            //与上一个方法不同的是形参的参数类型此处为double
            int sum2 =add(1,2,3);
            System.out.println(sum2);

        }

        public static int add(int a,int b) {//int a和int b是设立了两个形式参数a和b。
            return a+b;
        }
        public static int add(int a,int b,int c) {
          return a+b+c;
        }

        public static int add(double a,double b,double c) {
        return (int)(a+b+c);//强转成int
        }

}

输出结果：
3
==============
6
==============
6

命令行传参

我们可以用命令行给main方法传递参数。

具体代码如下：

package JavaSe.method;

public class Demo03 {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args["+i+"]"+ "is"+args[i] );

        }
    }
}

main方法本身也是一个方法，形参的参数类型为String.

复制该段代码到IDEA后会发现无法运行。

让我们用最原始的命令行的方式来运行java.

找到Demo03所在的文件夹，在路径框中输入cmd,回车即可打开命令行。

第一步

在命令行中输入javac Demo03.java回车，即可发现文件夹中已创建Demo03.class文件。
输入java Demo03会提示错误: 找不到或无法加载主类 Demo03.这是因为我们是从package JavaSe.method;包下导入的文件。我们需要退到JavaSE所在目录的上一级目录下才可以运行。即退到selfstudy所在目录。退回上级的命令为cd../

第二步

输入命令java JavaSe.method.Demo03
即可发现已经运行但是没有输出。因为我们还没有给它传参。

第三步

让我们给它传递参数：输入命令java JavaSe.method.Demo03 We are skillful coder!还可以在后面加上-Unicode utf8,回车即可看到输出结果：

第四步

以上即完成了命令行传参。

可变参数（不定项参数）

JDK1.5开始Java支持传递同类型的可变参数的方法。
在方法声明中，在指定参数类型后加一个省略号
一个方法中只能指定一个可变参数且它必须是方法的最后一个参数。其它普通参数必须在它之前声明。
不定项参数的实质是数组。

我们来看一个使用可变参数调用求和方法的例子：

public class Demo04 {
    public static void main(String[] args) {
        Demo04 demo04 = new Demo04();
        demo04.add(1,2,3,4);
       
    }
    public static void add(int...i){
        System.out.println(i[0]+i[1]+i[2]+i[3]);
    }
}

输出结果：
 10.0