【Java基础】15.方法调用、void关键字、方法重载、构造方法、可变参数

---

前言

Java方法是语句的集合，它们在一起执行一个功能。

• 方法是解决一类问题的步骤的有序组合。
• 方法包含于类或对象中
• 方法在程序中被创建，在其他地方被引用

一、方法的定义

1.命名规则

• 方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符。例如：addPerson。
• 下划线可能出现在 JUnit 测试方法名称中用以分隔名称的逻辑组件。一个典型的模式是：test<MethodUnderTest>_<state>，
  例如testPop_emptyStack。

2.定义

方法的定义：

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

方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

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

例子：

/**
     * 返回两个整型变量数据的较大值
     * @param num1
     * @param num2
     * @return
     */
    // 方法头：public static int max(int num1, int num2)
    // 修饰符：public static，public 访问修饰符，static 非访问修饰符
    // 返回类型：int
    // 方法名：max
    // 参数列表：int num1, int num2
    public static int max(int num1, int num2) {
        int result;
        if (num1 > num2){
            result = num1;
        }
        else{
            result = num2;
        }
        return result;
    }

注意： 在一些其它语言中方法指过程和函数。一个返回非void类型返回值的方法称为函数；一个返回void类型返回值的方法叫做过程。

二、方法调用

Java 支持两种调用方法的方式，根据方法是否返回值来选择。
当程序调用一个方法时，程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。
当方法返回一个值的时候，方法调用通常被当做一个值。例如：

int larger = max(30, 40);

如果方法返回值是void，方法调用一定是一条语句。例如，方法println返回void。下面的调用是个语句：

System.out.println("这是一条方法调用语句。");

实例：

/**
 * @ClassName: MethodDemo2
 * @Description: 方法介绍与调用
 * @author: Zh
 * @date: 2024/4/14 20:01
 */
public class MethodDemo2 {
    public static void main(String[] args) {
        int i = 5;
        int j = 2;
        int k = max(i, j); // 调用方法max
        System.out.println( i + " 和 " + j + " 比较，最大值是：" + k);
    }

    /**
     * 返回两个整型变量数据的较大值
     * @param num1
     * @param num2
     * @return
     */
    // 方法头：public static int max(int num1, int num2)
    // 修饰符：public static，public 访问修饰符，static 非访问修饰符
    // 返回类型：int
    // 方法名：max
    // 参数列表：int num1, int num2
    public static int max(int num1, int num2) {
        int result;
        if (num1 > num2){
            result = num1;
        }
        else{
            result = num2;
        }
        return result;
    }

}

编译运行结果如下：

5 和 2 比较，最大值是：5

这个程序包含 main 方法和 max 方法。main 方法是被 JVM 调用的，除此之外，main 方法和其它方法没什么区别。
main 方法的头部是不变的，如例子所示，带修饰符 public 和 static,返回 void 类型值，方法名字是 main,此外带个一个 String[] 类型参数。String[] 表明参数是字符串数组。

三、void 关键字

本节说明如何声明和调用一个 void 方法。
下面的例子声明了一个名为 printGrade 的方法，并且调用它来打印给定的分数。

public class MethodDemo2 {
    public static void main(String[] args) {
        printGrade(78.5); // 调用方法printGrade
    }

    /**
     * 判定分数
     * @param score
     */
    // 方法头：public static void printGrade(double score)
    // 修饰符：public static，public 访问修饰符，static 非访问修饰符
    // void 类型方法，不需要有返回类型
    // 方法名：printGrade
    // 参数列表：double score
    public static void printGrade(double score) {
        if (score >= 90.0) {
            System.out.println("分数" + score + ",绩效为：" + 'A');
        } else if (score >= 80.0) {
            System.out.println("分数" + score + ",绩效为：" + 'B');
        } else if (score >= 70.0) {
            System.out.println("分数" + score + ",绩效为：" + 'C');
        } else if (score >= 60.0) {
            System.out.println("分数" + score + ",绩效为：" + 'D');
        } else {
            System.out.println("分数" + score + ",绩效为：" + 'F');
        }
    }

}

编译运行结果如下：

分数78.5,绩效为：C

这里printGrade方法是一个void类型方法，它不返回值。
一个void方法的调用一定是一个语句。 所以，它被在main方法里以语句形式调用。就像任何以分号结束的语句一样。

四、通过值传递参数

调用一个方法时候需要提供参数，你必须按照参数列表指定的顺序提供。
例如，下面的方法连续n次打印一个消息：

public class MethodDemo2 {
    public static void main(String[] args) {
        nPrintln("Hello Java",3); // 调用方法nPrintln
    }

    /**
     * 通过值传递参数
     * @param message
     * @param n
     */
    public static void nPrintln(String message, int n) {
        for (int i = 0; i < n; i++) {
            System.out.println(message);
        }
    }

}

编译运行结果如下：

Hello Java
Hello Java
Hello Java

这个方法参数列表里有两个参数，分别是 String 类型的 message，和 int 类型的 n 。

五、方法重载

上面使用的max方法仅仅适用于int型数据。但如果你想得到两个浮点类型数据的最大值呢？
解决方法是创建另一个有相同名字但参数不同的方法，如下面代码所示：

public static double max(double num1, double num2) {
  if (num1 > num2)
    return num1;
  else
    return num2;
}

如果你调用max方法时传递的是int型参数，则 int型参数的max方法就会被调用；
如果传递的是double型参数，则double类型的max方法体会被调用，这叫做方法重载；
就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表。

Java编译器根据方法签名判断哪个方法应该被调用。
方法重载可以让程序更清晰易读。执行密切相关任务的方法应该使用相同的名字。
重载的方法必须拥有不同的参数列表。你不能仅仅依据修饰符或者返回类型的不同来重载方法。
实例：

/**
 * @ClassName: MethodDemo2
 * @Description: 方法重载
 * 方法重载：同一个类中，多个方法名称相同，形参列表不同
 * @author: Zh
 * @date: 2024/4/14 21:59
 */
public class MethodDemo2 {
    public static void main(String[] args) {
        open();
        open(11);
        open(34, 56);
        open(66.6, 8);
        OPEN();
    }

    /**
     * 新方法open
     */
    public static void open() {
        System.out.println("open方法(无参数)。");
    }

    /**
     * 重载方法open
     * @param a
     */
    public static void open(int a) {
        System.out.println("open方法,参数为int " + a);
    }

    /**
     * 重载方法open
     * @param a
     * @param b
     */
    static void open(int a, int b) {
        System.out.println("open方法,参数为int " + a + ",int " + b);
    }

    /**
     * 重载方法open
     * @param a
     * @param b
     */
    public static void open(double a, int b) {
        System.out.println("open方法,参数为double " + a + ",int " + b);
    }

    /**
     * 重载方法open
     * @param a
     * @param b
     */
    public static void open(int a, double b) {
        System.out.println("open方法,参数为int " + a + ",double " + b);
    }

    /**
     * 新方法OPEN
     */
    public static void OPEN() {
        System.out.println("OPEN方法(无参数)。");
    }

}

编译运行结果如下：

open方法(无参数)。
open方法,参数为int 11
open方法,参数为int 34,int 56
open方法,参数为double 66.6,int 8
OPEN方法(无参数)。

六、构造方法/构造器

当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。

通常会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来创建一个完整的对象。

不管你是否自定义构造方法，所有的类都有构造方法，因为 Java 自动提供了一个默认构造方法，默认构造方法的访问修饰符和类的访问修饰符相同(类为 public，构造函数也为 public；类改为 protected，构造函数也改为 protected)。

一旦你定义了自己的构造方法，默认构造方法就会失效。

实例：

/**
 * @ClassName: Student
 * @Description: 构造方法/构造器
 * @author: Zh
 * @date: 2024/4/14 22:19
 */
public class Student {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("贝吉塔");
        s1.setAge(22);
        Student s2 = new Student("孙悟空", 33);
        System.out.println(s1);
        System.out.println(s2.toString());
    }

    private String name; // 实例变量name
    private int age; // 实例变量age

    /**
     * 无参构造器
     */
    private Student() {
        System.out.println("无参数构造器执行！");
    }

    /**
     * 有参构造器
     *
     * @param name
     * @param age
     */
    public Student(String name, int age) {
        System.out.println("有参数构造器执行！");
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

}

编译运行结果如下：

无参数构造器执行！
有参数构造器执行！
Student{name='贝吉塔', age=22}
Student{name='孙悟空', age=33}

七、可变参数

JDK 1.5 开始，Java支持传递同类型的可变参数给一个方法。
方法的可变参数的声明如下所示：

typeName... parameterName

在方法声明中，在指定参数类型后加一个省略号(…) 。
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

可变参数的作用：

• 传输参数非常灵活，方便。
• 可以不传输参数。
• 可以传输一个参数。
• 可以传输多个参数。
• 可以传输一个数组。

可变参数在方法内部本质上就是一个数组。

可变参数的注意事项：

1. 一个形参列表中可变参数只能有一个！！
2. 可变参数必须放在形参列表的最后面！！

实例：

import java.util.Arrays;

/**
 * @ClassName: MethodDemo
 * @Description: 可变参数
 * 可变参数用在形参中可以接收多个数据。
 * 可变参数的格式：数据类型...参数名称
 * 可变参数的作用：
 * 1.传输参数非常灵活，方便。
 * 2.可以不传输参数。
 * 3.可以传输一个参数。
 * 4.可以传输多个参数。
 * 5.可以传输一个数组。
 * 可变参数在方法内部本质上就是一个数组。
 * 可变参数的注意事项：
 * 1.一个形参列表中可变参数只能有一个！！
 * 2.可变参数必须放在形参列表的最后面！！
 * @author: Zh
 * @date: 2024/4/14 22:41
 */
public class MethodDemo {
    public static void main(String[] args) {

        sum(); // 1、不传参数
        sum(10); // 2、可以传输一个参数
        sum(10, 20, 30); // 3、可以传输多个参数
        sum(new int[]{10, 20, 30, 40, 50}); // 4、可以传输一个数组
    }

    /**
     * 注意：一个形参列表中只能有一个可变参数,可变参数必须放在形参列表的最后面
     * @param nums
     */
    public static void sum(int... nums) {
        // 注意：可变参数在方法内部其实就是一个数组。 nums
        System.out.println("元素个数：" + nums.length);
        System.out.println("元素内容：" + Arrays.toString(nums));
    }
}

编译运行如下：

元素个数：0
元素内容：[]
元素个数：1
元素内容：[10]
元素个数：3
元素内容：[10, 20, 30]
元素个数：5
元素内容：[10, 20, 30, 40, 50]