方法的概念，以及概念

一、Java 方法的定义

方法是封装特定功能的代码块，定义需遵循固定结构，核心包含修饰符、返回值类型、方法名、参数列表、方法体五大部分。
这里提供了代码和结构图，更方便理解

package main.method;

import java.util.Scanner;

public class Method {


    public static void main(String[] args) {

//        请输入名字
        System.out.println("请输入名字");
        //调用外部的name来接收
        Scanner sc=new Scanner(System.in);
        String name=sc.next();
        //调用方法
        String study = new Method().study(name);
        System.out.println(study);

    }

    public String study(String name){
        return name+"在学习";
    }

}

二、方法重载（Overload）

同一个类中，方法名相同、参数列表不同（参数个数 / 类型 / 顺序不同）的多个方法，与返回值、修饰符无关，目的是让同一功能支持不同入参形式。

重载规则

• 必须在同一个类中；
• 方法名完全相同；
• 参数列表必须不同（仅参数名不同不算）；
• 返回值类型、修饰符可相同或不同（仅返回值不同不算重载）。

public class MethodOverload {
    // 基础版：两个int求和
    public int add(int a, int b) {
        return a + b;
    }

    // 重载1：三个int求和（参数个数不同）
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    // 重载2：两个double求和（参数类型不同）
    public double add(double a, double b) {
        return a + b;
    }

    // 重载3：参数顺序不同（int+String vs String+int）
    public void printInfo(int age, String name) {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }

    public void printInfo(String name, int age) {
        System.out.println("Age：" + age + "，Name：" + name);
    }

    public static void main(String[] args) {
        MethodOverload obj = new MethodOverload();
        System.out.println(obj.add(1, 2)); // 调用2个int参数的add，输出3
        System.out.println(obj.add(1, 2, 3)); // 调用3个int参数的add，输出6
        System.out.println(obj.add(1.5, 2.5)); // 调用2个double参数的add，输出4.0

        obj.printInfo(20, "张三"); // 输出：姓名：张三，年龄：20
        obj.printInfo("李四", 25); // 输出：Age：25，Name：李四
    }
}

三、方法重写（Override）

子类继承父类后，重写父类中非 private、非 final、非 static 的方法，要求方法名、参数列表、返回值类型完全一致（子类返回值可兼容父类，即协变返回），目的是修改父类方法的实现逻辑。
重写规则

• 发生在父子类之间；
• 方法签名（方法名 + 参数列表）完全相同；
• 子类方法的访问权限不能比父类更严格（如父类是 public，子类不能是 private）；
• 子类方法抛出的异常不能比父类更宽泛（如父类抛 NullPointerException，子类不能抛 Exception）；
• 静态方法不能被重写（子类同名静态方法只是隐藏父类方法，而非重写）。

// 父类
class Parent {
    // 父类方法：public权限
    public void showInfo() {
        System.out.println("父类的信息展示");
    }

    // 父类方法：返回值为Number
    public Number getNumber() {
        return 100;
    }

    // 静态方法（不能被重写）
    public static void staticMethod() {
        System.out.println("父类静态方法");
    }
}

// 子类
class Child extends Parent {
    // 重写父类的showInfo方法
    @Override // @Override注解：校验是否符合重写规则，建议加上
    public void showInfo() {
        // 可通过super调用父类原方法
        super.showInfo();
        System.out.println("子类重写后的信息展示");
    }

    // 协变返回值：子类返回值是父类返回值的子类（Integer是Number的子类）
    @Override
    public Integer getNumber() {
        return 200;
    }

    // 子类静态方法：只是隐藏父类静态方法，并非重写
    public static void staticMethod() {
        System.out.println("子类静态方法");
    }
}

public class MethodOverride {
    public static void main(String[] args) {
        Parent obj = new Child(); // 多态：父类引用指向子类对象
        obj.showInfo(); 
        // 输出：
        // 父类的信息展示
        // 子类重写后的信息展示

        System.out.println(obj.getNumber()); // 输出：200

        // 静态方法调用：看引用类型，而非对象类型
        obj.staticMethod(); // 输出：父类静态方法
        Child.staticMethod(); // 输出：子类静态方法
    }
}

四、基于方法的常见操作

1. 方法递归调用

方法自身调用自身，需注意终止条件（避免死递归），适用于分治场景（如阶乘、斐波那契数列）

public class MethodRecursion {
    // 递归计算阶乘：n! = n * (n-1)!
    public static int factorial(int n) {
        // 终止条件：n=1时返回1
        if (n == 1) {
            return 1;
        }
        // 递归调用
        return n * factorial(n - 1);
    }

    public static void main(String[] args) {
        System.out.println(factorial(5)); // 输出：120（5*4*3*2*1）
    }
}

2. 方法参数传递

Java 中参数传递规则：基本类型传值，引用类型传地址

public class MethodParam {
    // 基本类型参数：传递值的副本，原变量不受影响
    public static void changeInt(int num) {
        num = 100;
    }

    // 引用类型参数：传递地址，修改对象属性会影响原对象
    public static void changeObj(Person p) {
        p.setName("李四");
    }

    public static void main(String[] args) {
        // 基本类型传值
        int a = 10;
        changeInt(a);
        System.out.println(a); // 输出：10（原变量未变）

        // 引用类型传地址
        Person p = new Person("张三");
        changeObj(p);
        System.out.println(p.getName()); // 输出：李四（对象属性被修改）
    }
}

class Person {
    private String name;
    public Person(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}