JavaSE---方法的使用


public class Method
{ 
    // 方法定义
    public static boolean isLeapYear(int year)
    { 
        if((0 == year % 4 && 0 != year % 100) || 0 == year % 400)
        { 
            return true; 
        }
        else
        { 
            return false; 
        } 
    } 
}

【 注意事项 】

1. 修饰符：现阶段直接使用 public static 固定搭配

2. 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成void

3. 方法名字：采用小驼峰命名

4. 参数列表：如果方法没有参数， () 中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开

5. 方法体：方法内部要执行的语句

6. 在 java 当中，方法必须写在类当中

7. 在 java 当中，方法不能嵌套定义

8. 在 java 当中，没有方法声明一说

1.3 方法调用的执行过程

【 方法调用过程 】

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

【注意事项】定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行。一个方法可以被多次调用.

计算两个整数相加


public class Method 
{
    public static void main(String[] args) 
    { 
        int a = 10; int b = 20; 
        System.out.println("第一次调用方法之前"); 
        int ret = add(a, b); 
        System.out.println("第一次调用方法之后"); 
        System.out.println("ret = " + ret); 
        System.out.println("第二次调用方法之前"); 
        ret = add(30, 50); 
        System.out.println("第二次调用方法之后"); 
        System.out.println("ret = " + ret); 
    }
    public static int add(int x, int y) 
    { 
        System.out.println("调用方法中 x = " + x + " y = " + y); 
        return x + y; 
    } 
}

// 执行结果

一次调用方法之前

调用方法中 x = 10 y = 20

第一次调用方法之后

ret = 30

第二次调用方法之前

调用方法中 x = 30 y = 50

第二次调用方法之后

ret = 80

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


public class TestMethod 
{
    public static void main(String[] args) 
    { 
        int sum = 0; 
        for (int i = 1; i <= 5; i++) 
        { 
            sum += fac(i); 
        }
        System.out.println("sum = " + sum); 
    }
    public static int fac(int n) 
    { 
        System.out.println("计算 n 的阶乘中n! = " + n); 
        int result = 1;
        for (int i = 1; i <= n; i++) 
        { 
            result *= i; 
        }
        return result; 
    } 
}

// 执行结果

计算 n 的阶乘中 n ! = 1

计算 n 的阶乘中 n ! = 2

计算 n 的阶乘中 n ! = 3

计算 n 的阶乘中 n ! = 4

计算 n 的阶乘中 n ! = 5

sum = 153

使用方法, 避免使用二重循环 , 让代码更简单清晰

1.4 实参和形参的关系


public static int getSum(int N)
{ 
    // N是形参 
    return (1+N)*N / 2; 
}
getSum(10); // 10是实参,在方法调用时，形参N用来保存10


public static int add(int a, int b)
{ 
    return a + b; 
}
add(2, 3); // 2和3是实参，在调用时传给形参a和b

注意：在Java中，实参的值永远都是拷贝到形参中，形参和实参本质是两个实体

交换两个整型变量


public class TestMethod 
{
    public static void main(String[] args) 
    { 
        int a = 10; int b = 20; swap(a, b); 
        System.out.println("main: a = " + a + " b = " + b); 
    }
    public static void swap(int x, int y) 
    { 
        int tmp = x; 
        x = y; 
        y = tmp; 
        System.out.println("swap: x = " + x + " y = " + y); 
    } 
}

// 运行结果

swap : x = 20 y = 10

main : a = 10 b = 20

可以看到，在swap 函数交换之后，形参 x 和 y 的值发生了改变，但是 main 方法中 a 和 b 还是交换之前的值，即没有交换成功。

【 原因分析 】

实参a 和 b 是 main 方法中的两个变量，其空间在 main 方法的栈 ( 一块特殊的内存空间 ) 中，而形参 x 和 y 是 swap 方法中的两个变量，x 和 y 的空间在 swap 方法运行时的栈中，因此：实参 a 和 b 与形参 x 和 y 是两个没有任何关联性的变量，在 swap 方法调用时，只是将实参 a 和 b 中的值拷贝了一份传递给了形参 x 和 y ，因此对形参 x 和 y 操作不会对实参 a 和 b产生任何影响。

注意：对于基础类型来说, 形参相当于实参的拷贝. 即 传值调用

【 解决办法 】 : 传引用类型参数 ( 例如数组来解决这个问题 )


public class TestMethod 
{
    public static void main(String[] args) 
    { 
        int[] arr = {10, 20}; 
        swap(arr); 
        System.out.println("arr[0] = " + arr[0] + " arr[1] = " + arr[1]); 
    }
    public static void swap(int[] arr) 
    { 
        int tmp = arr[0]; 
        arr[0] = arr[1]; 
        arr[1] = tmp; 
    } 
}

// 运行结果

arr [ 0 ] = 20

arr [ 1 ] = 10

1.5 没有返回值的方法

方法的返回值是可选的. 有些时候可以没有的，没有时返回值类型必须写成 void


class Test 
{
    public static void main(String[] args) 
    { 
        int a = 10; 
        int b = 20;
        print(a, b); 
    }
    public static void print(int x, int y) 
    { 
        System.out.println("x = " + x + " y = " + y); 
    } 
}

2、方法重载

2.1 方法重载概念

在Java 中，如果多个方法的名字相同，参数列表不同，则称该几种方法被重载了 。


public class TestMethod 
{
    public static void main(String[] args) 
    { 
        add(1, 2); // 调用add(int, int) 
        add(1.5, 2.5); // 调用add(double, double) 
        add(1.5, 2.5, 3.5); // 调用add(double, double, double) 
    }
    public static int add(int x, int y) 
    { 
        return x + y;
    }
    public static double add(double x, double y) 
    { 
        return x + y; 
    }
    public static double add(double x, double y, double z) 
    { 
        return x + y + z; 
    } 
}

注意：

1. 方法名必须相同

2. 参数列表必须不同 ( 参数的个数不同、参数的类型不同、类型的次序必须不同 )

3. 与返回值类型是否相同无关


// 注意：两个方法如果仅仅只是因为返回值类型不同，是不能构成重载的
public class TestMethod 
{
    public static void main(String[] args) 
    { 
        int a = 10; 
        int b = 20; 
        int ret = add(a, b); 
        System.out.println("ret = " + ret); 
    }
    public static int add(int x, int y) 
    { 
        return x + y; 
    }
    public static double add(int x, int y) 
    { 
        return x + y; 
    } 
}

// 编译出错

Test . java : 13 : 错误 : 已在类 Test 中定义了方法 add ( int , int )

public static double add ( int x , int y ) {

^

1 个错误

4. 编译器在编译代码时，会对实参类型进行推演，根据推演的结果来确定调用哪个方法

2.2 方法签名

在同一个作用域中不能定义两个相同名称的标识符。比如：方法中不能定义两个名字一样的变量，那为什么类中就 可以定义方法名相同的方法呢？

方法签名即：经过编译器编译修改过之后方法最终的名字。具体方式：方法全路径名 + 参数列表 + 返回值类型，构成 方法完整的名字。


public class TestMethod 
{
    public static int add(int x, int y)
    { 
        return x + y; 
    }
    public static double add(double x, double y)
    {
        return x + y; 
    }
    public static void main(String[] args) 
    { 
        add(1,2); 
        add(1.5, 2.5); 
    } 
}

上述代码经过编译之后，然后使用 JDK 自带的 javap 反汇编工具查看，具体操作：

1. 先对工程进行编译生成 .class 字节码文件

2. 在控制台中进入到要查看的 .class 所在的目录

3. 输入： javap -v 字节码文件名字即可

方法签名中的一些特殊符号说明：

3、递归

递归求 N 的阶乘


public static void main(String[] args) 
{ 
    int n = 5; 
    int ret = factor(n); 
    System.out.println("ret = " + ret); 
}
public static int factor(int n) 
{ 
    if (n == 1) 
    { 
        return 1; 
    }
    return n * factor(n - 1);   // factor 调用函数自身 
}
 
// 执行结果 ret = 120

按照顺序打印数字的每一位


    public static void print(int n) {
        if(n < 10) {
            System.out.println(n);
        }else {
            print(n/10);
            System.out.println(n%10);
        }
    }

递归求一个整数各位数字之和


    public static int sumEvery(int n) {
        if(n < 10) {
            return n;
        }
        int tmp = n%10+sumEvery(n/10);
        return tmp;
    }

斐波那契数列


public class Test {
    public static int count = 0;
    
    public static int fib(int n) {
        if(n == 1 || n == 2) {
            return 1;
        }
        if(n == 3) {
            count++;
        }
        int tmp = fib(n-1)+fib(n-2);
        return tmp;
    }
 
    public static int fib2(int n) {
        if(n <= 0) {
            return -1;
        }
        if(n == 1 || n == 2) {
            return 1;
        }
        int f1 = 1;
        int f2 = 1;
        int f3 = -1;
        for (int i = 3; i <= n; i++) {
            f3 = f1+f2;
            f1 = f2;
            f2 = f3;
        }
        return f3;
    }
 
    public static void main(String[] args) {
 
        int ret = fib(41);
        System.out.println(ret+" 次数："+Test.count);
    }
}

相关阅读:
某马机房预约系统 C++项目（一）
家居行业如何借助AI营销数智化转型？《2023 家居行业AI营销第一课（重庆站）》给你答案
【学习总结】辐射、辐照等常见光学物理量的定义与关系
商业智能对企业来说意味着什么
gitee使用教程
报错的解决 sqlite3.OperationalError: unrecognized token: “630008.OF“
前端表单标签（二）
带你熟悉NLP预训练模型：BERT
2021年PHP-Laravel面试题问卷题答案记录
ASR语音识别纠错-fast correct

原文地址：https://blog.csdn.net/weixin_51912875/article/details/125709569