Java:方法的使用

一.什么是方法：

在 Java SE 中，方法是类中包含的功能块，它定义了一组执行某些操作的指令。方法用于封装可重复的代码逻辑，并使代码更简洁、易读和易维护。（类似于 C 语言中的 "函数"）

二.方法的语法格式

修饰符 返回类型 方法名(参数类型 参数名1, 参数类型 参数名2, ...) {
    // 方法体，执行的代码逻辑
    return 返回值; // 如果返回类型不是 void，则需要有 return 语句
}

示例1（斐波那契数列）

 public static void main(String[] args) {
        
    }
    public static int fib(int n){
        int f1=1;
        int f2=1;
        int f3=0;
        for (int i = 0; i <=n; i++) {
            f3=f1+f2;
            f1=f2;
            f2=f3;
        }
        return f3;
    }
    public static void main15(String[] args) {
        System.out.println(fib(4));
    }

示例2（两数相加之和）

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

    public static void main4(String[] args) {
        double a=1.0;
        double b=2.0;
        double c=add(a,b);
        System.out.println(c);
    }

示例3（依次按顺序打印每一位的数字）

  public static void print(int n){
        if(n>10){
            print(n/10);
        }
        System.out.println(n%10);
        return;
    }
    public static void main6(String[] args) {
        print(1234);
    }

 三.方法调用的执行过程

调用方法--->传递参数--->找到方法地址--->执行被调方法的方法体--->被调方法结束返回--->回到主调方法继续往下执行。

注意：1.定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行。

           2.一个方法可以被多次调用。

1.类型注意：

当同时要输入整形和字符串还有小数时，在输入整形后按回车，此时回车会被当作为字符串导致字符串无法输入，直接到小数的输入

方法：多加输入一个字符串，可以避免输完整形后输入回车被当成字符串进行输入。

    public static void main11(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("读一个整形");
        int age=scanner.nextInt();
        System.out.println(age);

        scanner.nextLine();//多加输入一个字符串，可以避免输完整形后输入回车被当成字符串进行输入

        System.out.println("读一个字符串");
        String str=scanner.nextLine();
        System.out.println(str);
        System.out.println("读一个小数");
        float f =scanner.nextFloat();
        System.out.println(f);

    }

 2.计算 1! + 2! + 3! + 4! + 5!

    public static int fac(int p){
         p=1;
        for (int i=1;i<6;i++){
         p*=i;
        }
        return p;
    }
    public static void main(String[] args) {
        int sum=0;
        for (int i = 0; i <6; i++) {
            sum+=fac(i);
        }
        System.out.println(sum);
    }

四.实参和形参的关系

在 Java SE 中，方法的实参（实际参数）和形参（形式参数）是方法调用和定义时密切相关的概念，它们之间的关系是方法参数传递的核心。

实参和形参的定义：

1.实参：

• 是方法定义中声明的参数，用于接收调用者传递的值。
• 形参是变量，在方法被调用时，它们会被赋值为实参的值。
• 形参存在于方法的参数列表中，定义形参的类型和名称。

public void add(int a, int b) {
    // 这里的 a 和 b 就是形参
    int sum = a + b;
    System.out.println("Sum: " + sum);
}

2.实参：

• 是在方法调用时传递给方法的实际值。
• 实参可以是常量、变量、表达式等，它们会被传递给对应的形参。
• 实参的类型和数量必须与形参的类型和数量相匹配。

public static void main(String[] args) {
    MyClass obj = new MyClass();
    obj.add(5, 10);  // 这里的 5 和 10 就是实参
}

3.两则和之间的关系：

• 形参是在方法定义中声明的变量，用于接收实参的值。
• 实参是在方法调用时实际传递的值。
• 对于基本数据类型，Java 采用值传递，方法内对形参的修改不会影响实参。
• 对于引用类型（如对象或数组），形参得到的是实参的引用副本，方法内对对象的修改会影响实参。

五.方法的重载

在 Java SE 中，方法重载（Method Overloading）是指在同一个类中可以定义多个方法名相同但参数列表不同的方法。这些方法在调用时，Java 会根据传递的参数类型和数量来决定调用哪个具体的方法。 

1.方法重载的条件：

• 参数的类型不同。
• 参数的数量不同。
• 参数的顺序不同（对于不同类型的参数）。

注意：方法的返回类型不影响重载，即方法重载不能仅通过改变返回类型来实现。 

public int add(int a, int b) {
        return a + b;
    }
    
    // 三个整数相加
    public int add(int a, int b, int c) {
        return a + b + c;
    }
    
    // 两个小数相加
    public double add(double a, double b) {
        return a + b;
    }

    // 两个不同类型的数相加
    public double add(int a, double b) {
        return a + b;
    }
    
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        
        // 调用不同的重载方法
        System.out.println(calc.add(5, 10));         // 调用第一个 add 方法
        System.out.println(calc.add(1, 2, 3));      // 调用第二个 add 方法
        System.out.println(calc.add(2.5, 3.5));     // 调用第三个 add 方法
        System.out.println(calc.add(5, 3.5));       // 调用第四个 add 方法
    }

输出结果：

六.递归

在 Java SE 中，递归是指方法在其内部调用自己。递归方法通过将问题分解为更小的子问题并逐步解决，最终达到终止条件。递归是一种强大的编程技术，尤其适用于处理可以按某种方式划分为更小规模的相似问题的场景。

1.递归的原理：

每次递归调用时，当前方法的执行都会暂停，等待递归调用的结果返回后再继续执行。递归调用沿着递归链向下逐步求解，最终达到终止条件，随后沿着递归链向上逐层返回结果。

2.求递归1-10的和 

    public static int add1(int n){
        if (n==0) {
            return 1;
        }
        return n+add1(n-1);
    }
    public static void main7(String[] args) {
        int c=add1(10);
        System.out.println(c);
    }

3.用递归方法求斐波那契数列（不推荐，所占用栈的空间太大）

    public static int fib2(int n){
        if(n==1 ||n==2){
            return 1;
        }
        return fib2(n-2)+fib2(n-1);
    }
    public static void main14(String[] args) {
        System.out.println(fib2(6));
    }

希望能对大家的学习有所帮助！！！