Java零基础入门笔记：(4)方法

前言

本笔记是学习狂神的java教程，建议配合视频，学习体验更佳。

【狂神说Java】Java零基础学习视频通俗易懂_哔哩哔哩_bilibili

第1-2章：Java零基础入门笔记：(1-2)入门（简介、基础知识）-CSDN博客

第3章：Java零基础入门笔记：(3)程序控制-CSDN博客

方法

何谓方法

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

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

设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样利于我们后期的扩展。

下面的代码定义了一个add方法，用于实现两个数的加法。

• static 关键字用于修饰方法时，这种类型的方法被称为静态方法（Static Method）。

package method;

public class demo1 {
    public static void main(String[] args) {
        int sum = add(1,2);
        System.out.println(sum);
    }
    
    public static int add(int a, int b){    // static变成类方法，这样main里面就能调用了
        return a+b;
    }
}

3

方法的定义

在编程中，方法（Method） 是一种封装了特定功能的代码块，用于执行特定的任务或计算。方法允许我们将复杂的程序分解为更小的、可重用的模块，从而使代码更加清晰、易于维护和扩展。

Java的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法：

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

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

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

下面的代码定义了一个比大小的方法：

1. main 方法 ：调用 max 方法，传入两个整数 1 和 2。将 max 方法的返回值赋值给变量 m。

2. max 方法：

   1. 返回类型是 int，表示方法返回一个整数。方法接收两个整数参数 a 和 b。

   2. 定义一个变量 result，并初始化为 b。使用 if 语句判断 a 是否大于 b：如果 a > b，则将 result 的值更新为 a。最后，使用 return result; 返回较大的值。

package method;

public class demo1 {
    public static void main(String[] args) {
        int m = max(1, 2);
        System.out.println(m);
    }

    public static int max(int a, int b){
        int result = b;     // 返回值一定要初始化，其他的变量可以不初始化
        if (a > b){
            result = a;
        }
        return result;
    }
}

2

方法调用

调用方法：对象名.方法名(实参列表)

Java支持两种调用方法的方式，根据方法是否返回值来选择。

当方法返回一个值的时候，方法调用通常被当做一个值。例如：

int larger = max(30,40);

如果方法返回值是void，方法调用一定是一条语句。如：

System.out.println( "Hello,kuangshen! ");

课后拓展了解：值传递（Java） 和 引用传递

值传递： 是指方法接收的是实际参数的副本，而不是参数本身。这意味着在方法内部对参数的修改不会影响原始变量。

• 参数的值被复制到方法的局部变量中。
• 方法内部对参数的修改不会影响外部的原始变量。

引用传递 ：Java 中的引用传递实际上是引用的值传递 ，而不是真正的引用传递。方法接收的是对象引用的副本，但这个副本指向同一个对象。

• 方法接收的是对象引用的副本。

• 方法内部对对象的修改会影响原始对象，因为它们指向同一个内存地址。

• 但方法不能改变引用本身（即不能改变对象的指向）。

方法重载

方法重载 是 Java 中的一个重要特性，允许在**同一个类中定义多个同名方法，只要它们的参数列表不同。**方法重载是实现多态的一种方式，可以让方法根据传入的参数类型和数量选择不同的实现。

方法的重载的规则:

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

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

下面的代码演示了一个方法重载的代码：在代码中，两个max方法名字一样，但参数类型不同，因此在调用时会根据不同的参数调用不同的方法。

package method;

public class demo1 {
    public static void main(String[] args) {
        int m = max(1, 2);      // 调用第一个
        System.out.println(m);
        double m1 = max(1.0, 2.0);   // 调用第二个
        System.out.println(m1);

    }

    public static int max(int a, int b){
        int result = b;     // 返回值一定要初始化，其他的变量可以不
        if (a > b){
            result = a;
        }
        return result;
    }
    public static double max(double a, double b){
        double result = b;     // 返回值一定要初始化，其他的变量可以不
        if (a > b){
            result = a;
        }
        return result;
    }

}

2
2.0

命令行传参

运行一个程序时候再传递给它消息。这要靠传递命令行参数给main()函数实现。

这段代码的功能是遍历命令行参数数组 args，并打印每个参数的索引和值。

• args 是 main 方法的参数，用于接收从命令行传入的字符串数组。args.length 表示命令行参数的数量。
• 在循环中，使用 System.out.println 打印每个参数的索引和值。格式为：args[i]: 参数值。

package scanner;

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

下面演示了如何在命令行使用参数，

• 在第一个java scanner.demo1中，无参数输入，因此也无任何输出
• 在第一个java scanner.demo1中，有4个参数，因此打印4行

需要注意，编译后要退到src才能运行

PS E:\Java_Demo\demo\src> cd .\scanner\
PS E:\Java_Demo\demo\src\scanner> javac demo1.java
PS E:\Java_Demo\demo\src\scanner> cd ..
PS E:\Java_Demo\demo\src> java scanner.demo1
PS E:\Java_Demo\demo\src> java scanner.demo1 this is sherlock ma
args[0]: this
args[1]: is
args[2]: sherlock
args[3]: ma

可变参数

在 Java 中，可变参数（Varargs） 是一种特殊的参数类型，允许方法接收任意数量的参数。可变参数通常用于需要处理多个参数但不确定具体数量的场景。

**语法：**在方法声明中，在指定参数类型后加一个省略号(....)。

• 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
• 只能有一个可变参数
• 其本质是数组，可以使用数组的方法和属性。例如：numbers.length、numbers[i]。

下面的代码演示了使用可变参数接收任意数量的数字，并找出其中的最大值。

1. printMax 方法：

   • 方法定义为 public static void printMax(double... numbers)，表示可以接收任意数量的 double 类型参数。

   • 参数 numbers 在方法内部被视为一个 double 类型的数组。

2. 检查参数数量：

   • 如果没有传入任何参数（numbers.length == 0），打印 "No argument passed" 并返回。

3. 寻找最大值：

   • 假设第一个参数是最大值（result = numbers[0]）。

   • 使用 for 循环遍历数组，比较每个元素是否大于当前的最大值。

   • 如果找到更大的值，则更新 result。

package method;

public class demo1 {
    public static void main(String[] args) {
        printMax(34, 3, 3, 2, 56.5);
    }

    public static void printMax( double... numbers) {
        if (numbers. length == 0) {
            System.out.println("No argument passed");
            return;
        }

        double result = numbers[0];

        //遍历数组！
        for (int i = 1; i < numbers.length; i++){
            if (numbers[i] > result) {
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }

}

The max value is 56.5

递归

递归就是：A方法调用A方法！就是自己调用自己

利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。

递归结构包括两个部分：

• 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
• 递归体：什么时候需要调用自身方法。

下面的代码不要跑，死循环！

package com.dawnsmile.method;
 
public class Demo05 {    // 死循环！
    public static void main(String[] args) {
        Demo05 test = new Demo05();
        test.test();
    }
 
    public void test(){
        test();
    }
}

下面的代码演示了如何使用递归计算阶乘

1. factorial 方法：

   1. 如果 n <= 1，返回 1（阶乘的基本情况：0! = 1 和 1! = 1）。

   2. 否则，递归调用 factorial(n-1)，并将结果乘以 n（递归公式：n! = (n-1)! * n）。

package scanner;

public class demo1 {
    public static void main(String[] args) {
        int result = factorial(5);
        System.out.println(result);
    }

    public static int factorial(int n){
        if(n <= 1){
            return 1;
        }else {
            return factorial(n-1) * n;
        }
    }
}

120

其运算过程如下：

factorial(5) = factorial(4) * 5
factorial(4) = factorial(3) * 4
factorial(3) = factorial(2) * 3
factorial(2) = factorial(1) * 2
factorial(1) = 1

因此，factorial(5) 的计算过程为：factorial(5) = 1 * 2 * 3 * 4 * 5 = 120

-

练习

写一个计算器，要求能实现加减乘除，并且能不断循环接收新的数据，通过用户交互实现。

package scanner;
import java.util.Scanner;

public class demo1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入符号，按q退出：");
        String s = scanner.next();
        while (!s.equals("q")){
            if (!(s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/"))){
                System.out.println("异常值！");
                break;
            }
            
            System.out.print("请输入第一个数字：");
            int a = scanner.nextInt();
            System.out.print("请输入第二个数字：");
            int b = scanner.nextInt();
            
            switch (s){
                case "+":
                    System.out.println(add(a, b));
                    break;
                case "-":
                    System.out.println(subtract(a, b));
                    break;
                case "*":
                    System.out.println(multiply(a, b));
                    break;
                case "/":
                    System.out.println(divide(a, b));
                    break;
            }
            
            System.out.print("请输入符号，按q退出：");
            s = scanner.next();
        }
    }

    public static int add(int a, int b) {
        return a + b;
    }

    public static int subtract(int a, int b) {
        return a - b;
    }

    public static int multiply(int a, int b) {
        return a * b;
    }

    public static int divide(int a, int b) {
        return a / b;
    }
}

🚀 知识的力量在于分享！ 🚀

如果你从我的分享中学到了新知识，或者觉得这些内容对你有帮助，请不吝点赞、关注和收藏！这样不仅能让我更有动力，还能帮助更多人看到这些内容。

• 👍 点赞：让我知道你收获了！

• 👀 关注：获取更多干货！

• ⭐️ 收藏：方便随时复习！

感谢您的支持，我们一起进步！