核心概念：方法

在 Java 中，我们通常不直接说 "function"，而是说 方法，方法是定义在类中的一个代码块，用于执行特定的任务，它有以下几个关键部分：

1. 方法名：方法的名称。
2. 参数列表：方法接收的输入数据。
3. 返回类型：方法执行完毕后返回的数据类型，如果没有返回值，则使用 void。
4. 方法体：包含具体逻辑的代码块。

下面是一个最简单的例子,展示如何定义和调用一个方法。

定义一个方法

// 这是一个名为 sayHello 的方法
// 它没有参数 (括号内为空)
// 它没有返回值 (返回类型为 void)
public void sayHello() {
    System.out.println("Hello, World!");
}
// 这是一个名为 addNumbers 的方法
// 它有两个 int 类型的参数: num1 和 num2
// 它返回一个 int 类型的值
public int addNumbers(int num1, int num2) {
    int sum = num1 + num2;
    return sum; // 返回计算结果
}

调用一个方法

调用方法就是使用方法名并传递所需的参数（如果有）。

public class Main {
    public static void main(String[] args) {
        // 创建 Main 类的实例
        Main myMain = new Main();
        // 调用 sayHello() 方法
        // 注意：调用无参数、无返回值的方法时，只需写方法名加括号
        myMain.sayHello(); // 输出: Hello, World!
        // 调用 addNumbers() 方法
        // 我们需要一个变量来接收它的返回值
        int result = myMain.addNumbers(5, 10);
        System.out.println("The sum is: " + result); // 输出: The sum is: 15
    }
    // ... 在这里定义 sayHello 和 addNumbers 方法 ...
    public void sayHello() {
        System.out.println("Hello, World!");
    }
    public int addNumbers(int num1, int num2) {
        return num1 + num2;
    }
}

进阶概念：静态方法

当一个方法不需要访问任何实例变量（即类的非静态字段）时，我们可以将它声明为 static，静态方法属于类本身，而不是类的某个实例。

• 如何调用：可以直接通过类名来调用，无需创建实例。

public class MathUtils {
    // 这是一个静态方法
    public static int multiply(int a, int b) {
        return a * b;
    }
    // 这是一个非静态方法（实例方法）
    public double divide(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("Cannot divide by zero");
        }
        return (double) a / b;
    }
}
public class Main {
    public static void main(String[] args) {
        // 调用静态方法
        // 直接使用类名.方法名()
        int product = MathUtils.multiply(7, 8);
        System.out.println("The product is: " + product); // 输出: The product is: 56
        // 调用非静态方法
        // 必须先创建类的实例
        MathUtils myMath = new MathUtils();
        double quotient = myMath.divide(20, 4);
        System.out.println("The quotient is: " + quotient); // 输出: The quotient is: 5.0
    }
}

现代概念：函数式编程

从 Java 8 开始，Java 引入了函数式编程的特性，使得代码更简洁、更灵活，这里的关键是 Lambda 表达式 和 函数式接口。

Lambda 表达式

Lambda 表达式是一种匿名函数，它没有名称，但可以作为方法参数传递或赋值给变量。

它的基本语法是：(parameters) -> { body }

// 传统方式（使用匿名内部类）
Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello from traditional way!");
    }
};
// 使用 Lambda 表达式
Runnable r2 = () -> System.out.println("Hello from Lambda!");
// 调用
r1.run();
r2.run();

函数式接口

函数式接口是只有一个抽象方法的接口,Lambda 表达式的类型就是函数式接口，Java 在 java.util.function 包中提供了许多常用的函数式接口。

• Runnable：无参数，无返回值 (() -> void)
• Function<T, R>：一个参数，一个返回值 ((T) -> R)
• Consumer<T>：一个参数，无返回值 ((T) -> void)
• Supplier<T>：无参数，一个返回值 (() -> T)

示例：java.util.function.Function

import java.util.function.Function;
public class Main {
    public static void main(String[] args) {
        // 定义一个函数，它接收一个 Integer，返回一个 String
        // Function<Integer, String> 的意思是：输入是 Integer，输出是 String
        Function<Integer, String> intToString = number -> "The number is: " + number;
        // 调用这个函数
        String result = intToString.apply(100);
        System.out.println(result); // 输出: The number is: 100
        // 更复杂的例子：链式调用
        // 先将数字平方，再转为字符串
        Function<Integer, Integer> square = number -> number * number;
        Function<Integer, String> squareToString = square.andThen(intToString);
        String result2 = squareToString.apply(5);
        System.out.println(result2); // 输出: The number is: 25
    }
}

方法引用

Lambda 表达式只是简单地调用一个已有的方法，可以使用方法引用来使代码更简洁。

import java.util.function.Function;
public class Main {
    public static void main(String[] args) {
        // 使用 Lambda 表达式
        Function<String, Integer> lambdaLength = s -> s.length();
        // 使用方法引用
        // String::length 是对 String 类的 length() 方法的引用
        Function<String, Integer> methodRefLength = String::length;
        System.out.println(lambdaLength.apply("Hello"));      // 输出: 5
        System.out.println(methodRefLength.apply("Java"));    // 输出: 4
    }
}

总结与选择

对于初学者来说,首先要掌握方法、静态方法的定义和调用，这是 Java 编程的基石，当你对基础非常熟悉后，再学习 Lambda 表达式和函数式编程，你会发现它们能让你的代码变得更加优雅和强大。