华山论剑之JAVA中的“方法论”

这里是：钮钴禄.爱因斯晨~
更多精彩：个人主页
JAVA专栏：Java
热门文章1：赛博算命之梅花易数
热门文章2：赛博算命之周易六十四卦
大佬们互三哦~~互三必回，后台踢踢哦~

前言
在 Java 编程的广袤世界里，方法作为构建程序逻辑的基础单元，扮演着举足轻重的角色。无论是处理复杂的业务逻辑，还是实现精妙的数据处理，都离不开方法的运用。本文将深入剖析 Java 中方法的用法，从基础概念到进阶技巧，为你呈现方法在 Java 编程中的多样应用，助你夯实编程基础，提升编程能力。

一、什么是方法

1.什么是方法?

方法（method）是程序中最小的执行单元。

public class fang {
    //以下是main方法，主方法
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

2.方法有什么用呢？

需求：用输出语句描述，如何打一局游戏呢？

我们可以想到以下的代码实现

public class fang {
    public static void main(String[] args) {
        System.out.println("选人物");
        System.out.println("鲁班七号");
        System.out.println("开局");
        System.out.println("对战");
        System.out.println("崩盘");
    }
}

如果我们打两局游戏呢？

public class fang {
    public static void main(String[] args) {
        System.out.println("选人物");
        System.out.println("鲁班七号");
        System.out.println("开局");
        System.out.println("对战");
        System.out.println("崩盘");
        
        System.out.println("选人物");
        System.out.println("鲁班七号");
        System.out.println("开局");
        System.out.println("对战");
        System.out.println("崩盘");
    }
}

难道要重复输出这些行代码吗？这样很不简洁，于是我们想到了打包

//打包为PlayGame，这里打包的整体就是我们要学的方法
        System.out.println("选人物");
        System.out.println("鲁班七号");
        System.out.println("开局");
        System.out.println("对战");
        System.out.println("崩盘");

//我们可以把代码优化为
public class fang {
    public static void main(String[] args) {
        调用PlayGame方法
        调用PlayGame方法
    }
}    

实际开发中方法的应用场景

我们玩过植物大战僵尸，其中豌豆射手射击我们可以写多行代码，寒冰射手射击我们也要写多行代码，为了保证代码的简洁性，提高我们的写作效率我们可以把发射炮弹打包为一个方法。

综上：重复的代码、具有独立功能的代码可以抽取到方法中。

3.方法的优势：

可以提高代码的复用性

可以提高代码的可维护性

二、方法的格式

把一些代码打包在一起，用到的时候就调用

1.方法定义

把一些代码打包在一起，该过程称为方法定义

1.1方法的定义格式

public static 返回值类型 方法名（参数）{
    方法体;
    return 返回值;
}

public static int sum (int a){
    方法体;
    return 返回值;
}

1.2最简单的方法定义

格式：
    
public static void 方法名（）{
    方法体（就是打包起来的代码）;
}

范例：

public static void PlayGame(){
    //七个打印语句;
    System.out.println("选人物");
    System.out.println("鲁班七号");
    System.out.println("开局");
    System.out.println("对战");
}    

注：方法名要遵从驼峰命名法：

一个单词全部小写，两个单词每个单词的首字母大写

1.3带参数的方法定义

为什么要有带参数的方法呢？
因为我们日常会遇到大量不明确的数据，不可能深入程序内部去改变量

格式：
    
public static void 方法名（参数1,参数2）{
    方法体（就是打包起来的代码）;
}

//小括号中写的是要调用的值，写几个必须调用几个，多一个少一个都不行。
//个数要对应，数据类型也要对应

范例：
    
 public static void sum (int num1 , int num2);   

1.4带返回值的方法的定义

为什么要有返回值呢？

• 如果在调用处要根据方法的结果，去编写另外一段代码逻辑
• 为了在调用处拿到方法产生的结果，就需要定义带有返回值的方法。

格式：

public static 返回值类型 方法名 （参数）{
    方法体;
    return 返回值;
}

范例：
    
public static int sum (int a, int b ){
    int c = a+b;
    return c;
}

2.方法调用

方法定义后并不是直接运行的，需要手动调用才能运行，该过程称为方法调用

2.1最简单的方法调用

格式：

    方法名（）;
    
范例：

    PlayGame();

注：方法要先定义后调用，否则会报错。

public class diao {
    public static void main(String[] args) {
        // 方法的调用
        PlayGame();
        PlayGame();
    }
    // 方法的定义要写在main方法外面，类的里面
    public static void PlayGame(){
        System.out.println("选人物");
        System.out.println("鲁班七号");
        System.out.println("开局");
        System.out.println("对战");
    }
}

练习：

//练习1
public class diao {
    public static void main(String[] args) {
        System.out.println("a");
        method();
        System.out.println("b");
    }
    // 方法的定义要写在main方法外面，类的里面
    public static void method(){
        System.out.println("c");
        System.out.println("d");
    }
}

run:
a
c
d
b

//练习2
public class fafa {
    public static void main(String[] args) {
        System.out.println("a");
        method1();
        System.out.println("b");
    }
    public static void method1() {
        method2();
        System.out.println("c");
    }
    public static void method2() {
        System.out.println("d");
        System.out.println("e");
    }
}

run:
a
d
e
c
b

看到方法进入方法，执行完毕回到调用处。

//人肉计算器
//需求：定义一个方法，在方法内部定义两个变量。求出他们的和并进行打印。
//目标：利用方法最简单的格式完成当前练习
public class ren {
    public static void main(String[] args) {
        sum();

    }
    public static void sum() {
        int num1 = 10;
        int num2 = 20;
        int result = num1 + num2;
        System.out.println("结果是："+result);

    }
}

run:
30
//可是当我们平常计算时不可能挨个进入程序里改变量，于是就诞生了带参数的调用方法。

2.2带参数的方法调用

单个参数：

格式：
    
方法名（参数）;

范例：

method (10);
method (变量);

多个参数：

格式：

方法名（参数1,参数2）;

范例：

sum(10,20);
sum(变量1,变量2);

注意：

方法调用时，参数的数量与类型必须与方法定义中小括号里面的变量一一对应，否则程序将报错。

例题：
//人肉计算器进阶版
import java.util.Scanner;
public class renone {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数字");
        int num1 = sc.nextInt();
        System.out.println("请输入一个数字");
        int num2 = sc.nextInt();
        // 将 num1 和 num2 作为参数传递给 sum 方法
        sum(num1, num2);//实参
    }

    // 修改 sum 方法，接受两个整数参数
    public static void sum(int num1, int num2) {//形参
        int result = num1 + num2;
        System.out.println("结果是："+result);
    }
}

拓展：

形参：

全称形式参数，是指方法定义中的参数。

实参：

全称实际参数，方法调用中的参数。

于是，上文注意即可改写成：方法调用时，实参和形参必须一一对应，否则程序将报错。

方法定义小技巧：

1.我要干什么？方法体

2.我干这件事要怎么才能完成？形参

练习：
    
//需求：定义一个方法，求长方形的周长，将结果在方法中进行打印
//目标：根据不同的需求，选择定义无参的方法，还是带参的方法。

//1.我要干什么？ 求长方形的周长
//2.我怎么干这件事？ 定义方法（长+宽）*2

代码实现：
import java.util.Scanner;
public class can {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入这个长方形的长：");
        int chang = sc.nextInt();
        System.out.println("请输入这个长方形的宽：");
        int kuan = sc.nextInt();
        sum (chang,kuan);


    }
    public static void sum(int chang,int kuan) {
        int sumo = (chang + kuan)*2;
        System.out.println("这个长方形的周长是："+sumo);
    }
}

2.3带返回值的方法调用

直接调用：

方法名（实参）;

赋值调用：

整数类型 变量名 = 方法名（实参）;
int c = sum (a,b);

输出调用：

System.out.println(方法名(实参));
System.out.println(sum(a,b));

练习：
    
import java.util.Scanner;
public class fan {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int a = sc.nextInt();
        System.out.println("请输入一个整数：");
        int b = sc.nextInt();
        //赋值调用
        //int c = sum(a,b);
        //输出调用
        //System.out.println(sum(a,b));
    }
    public static  int sum (int a, int b) {
       //返回值
        return a+b;
    }
}

练习2：比较长方形大小

public class mian {
    public static void main(String[] args) {
        int result = area(10, 20);
        int result2 = area(30, 50);
        if (result > result2) {
            System.out.println("第一个面积大");
        }else {
            System.out.println("第二个面积大");
        }
    }
    public static int area (int len, int wei) {
        return len * wei;
    }
}

3.方法的注意事项

• 方法不调用就不执行
• 方法与方法之间是平级关系，不能互相嵌套定义
• 方法的编写顺序和执行顺序无关，谁先调用，谁先执行
• 方法的返回值为void，表示该方法没有返回值，没有返回值的方法可以省略return语句不写。如果要编写return，后面不能跟具体的数据。
• return语句下面，不能编写代码，因为永远执行不到，属于无效的代码。

return关键字

• 方法没有返回值：可以省略不写。如果书写，表示结束方法。
• 方法有返回值：必须要写。表示结束方法和返回结果。

三、方法的重载

1.定义

• 在同一个类中，定义多个同名的方法，这些同名的方法具有同种的功能。
• 每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成了重载关系。
• 简单记：同一类中，方法名相同，参数不同的方法，与返回值无关。
• 参数不同：个数不同，类型不同，顺序不同。
• JAVA虚拟机会通过参数的不同来区分同名的方法。

2.定义重载的方法

public class fang {
    public static void main(String[] args) {
        bi(1,1); 
    }
    public static void bi(byte b1, byte b2) {
        System.out.println(b1==b2);
    }
    public static void bi(short b1, short b2) {
        System.out.println(b1==b2);
    }
    public static void bi(int b1, int b2) {
        System.out.println(b1==b2);
    }
    public static void bi(double b1, double b2) {
        System.out.println(b1==b2);
    }
    
}

打印的注意事项

println("abc") "先打印abc,再换行"
print("abc") “打印abc不换行”

//需求：设计一个数组遍历，要求遍历的结果是在一行的。例如[11,22,33,44,55]
方法一：
public class da {
    public static void main(String[] args) {
        int [] arr ={11,22,33,44,55};
        for (int i = 0; i < arr.length; i++) {
            if (i==0){
                System.out.print("["+arr[i]);
            }else{
                System.out.print(","+arr[i]);
            }
        }
        System.out.print("]");
    }
}

方法二
    
public class datwo {
    public static void main(String[] args) {
        int [] arr ={11,22,33,44,55};
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i==arr.length-1){
                System.out.print(arr[i]+"]");
            }else{
                System.out.print(arr[i]+",");
            }
        }
    }
}

//练习2
//求数组的最大值。需求：设计一个方法求数组的最大值，并将最大值返回
public class o {
    public static void main(String[] args) {
        int [] arr ={66,22,33,44,55};
        int sum = bijiao(arr);
        System.out.println("数组中最大值为："+sum);
    }
    public static int bijiao( int []arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > sum) {
                sum = arr[i];
            }
        }
        return sum;
    }
}

//练习3，需求：创建一个方法，查找某个数字在数组中是否存在

import java.util.Scanner;
public class contains {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int [] arr ={11,22,33,44,55};
        System.out.println("请输入要查找的数字");
        int a = sc.nextInt();
        boolean b = cont(arr,a);// 调用方法，定义一个变量接受返回值，返回值是boolean类型，方法名（参数）
        System.out.println(b);

    }
    public static boolean cont(int [] arr,int a){
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]==a){
                return true;
            }
        }
        return false;
        //如果将false放在循环外，那么当循环结束后，没有找到，就会返回false。
        //如果放里面，一次没有找到，就直接结束程序了
    }
}

注：return 和 break 的区别

return：其实跟循环没啥关系，跟方法有关，表示结束方法，返回结果。

如果方法执行到了return，那么整个方法全部结束，里面的循环也会随之结束。

break：跟方法没什么关系，结束循环或者swtich.

练习4：
//需求：定义一个方法copyofrange(int [] arr,int from,int to )
//功能：将数组arr中索引from（包含from)开始。到索引to结束（不包含to)的元素复制到新数组中，将新数组返回。

四、方法的内存

1.java内存分配

栈：方法运行时使用的内存，方法进栈运行，运行完毕就出栈

堆：new出来的，都在堆内存中开辟了一个小空间

2.方法调用的基本内存原理

方法被调用之后就会进栈执行

先进后出

每个方法执行完，就会出栈

public class duu {
    public static void main(String[] args) {
        eat();
    }
    public static void eat() {
        study();
        System.out.println("吃饭");
        sleep();
    }
    public static void sleep() {
        System.out.println("睡觉");
    }
    public static void study() {
        System.out.println("学习");
    }
}

详细执行步骤：
main() 方法入栈
main() 调用 eat() → eat() 入栈
eat() 调用 study() → study() 入栈
study() 执行打印"学习" → 出栈
eat() 继续执行打印"吃饭"
eat() 调用 sleep() → sleep() 入栈
sleep() 执行打印"睡觉" → 出栈
eat() 执行完毕 → 出栈
main() 执行完毕 → 出栈
完整执行顺序（用→表示栈操作）： main()入栈 → eat()入栈 → study()入栈 → study()出栈 → sleep()入栈 → sleep()出栈 → eat()出栈 → main()出栈

3.方法传递基本数据类型的内存原理

3.1基本数据类型和引用数据类型

基本数据类型：变量里面存储是真实的数据

引用数据类型：堆中存储的数据类型，也就是new出来的，变量中存储的是地址值。引用：就是使用其他空间中数据的意思。

3.1.1从内存的角度去解释：

基本数据类型：数据值是存储在自己的空间中

特点：赋值给其他变量，也是赋的真实的值。

引用数据类型:数据是存储在其他空间中，自己空间中存储的是地址值。

特点：赋值给其他变量，赋的地址值

public class cun {
    public static void main(String[] args) {
        int number = 1;
        System.out.println("调用change方法前："+number);
        change(number);
        System.out.println("调用change方法后："+number);
    }
    public static void change(int number) {
        number = 2;
    }
}
打印出来都是1

在Java中，基本数据类型（如int）的方法参数传递是按值传递的。以下是关键点解释：

参数传递机制

当调用change(number)时，传递的是变量number值的拷贝（即数字1），而不是变量本身27。
方法内部的number = 2仅修改了拷贝的值，不会影响主方法中的原始变量2。
内存变化过程

调用前：主方法中的number存储在栈内存，值为1。
调用时：将1拷贝到change()方法的参数number中，此时两个number变量地址不同。
调用后：change()方法的局部变量被销毁，主方法的number仍为127。
与引用传递的区别

如果参数是对象类型，传递的是对象引用的拷贝（类似指针拷贝），修改对象属性会影响原始对象。但基本类型没有这种特性27。
代码执行流程示例：

java
复制
public static void main(String[] args) {
    int number = 1;  // 原始变量（地址A）
    change(number);   // 传递1的拷贝到新地址B
    // 方法结束后，地址B的修改不影响地址A
}

public static void change(int number) { 
    number = 2;      // 修改的是地址B的值
}
总结：基本类型参数传递的是值的副本，方法内部操作的是副本，因此原始变量不受影响。

传递基本数据类型时，传递的是真实的数据，形参的改变，不影响实际参数的值

public class cun {
    public static void main(String[] args) {
        int number = 1;
        System.out.println("调用change方法前："+number);
        number=change(number);
        System.out.println("调用change方法后："+number);
    }
    public static int change(int number) {
        number = 2;
        return number;
    }
}
打印出来一个是1一个是2

4.方法传递引用数据类型的内存原理

public class chuandi {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5}; // 在堆中创建数组对象，栈中的nums变量存储堆地址
        System.out.println("调用change方法前："+nums[0]); // 输出1
        change(nums);    // 传递的是堆地址的副本
        System.out.println("调用change方法后："+nums[0]); // 输出5
    }
    public static void change(int[] nums) {
        nums[0] = 5;    // 通过复制的地址找到堆中的原始数组，修改实际数据
    }
}
run:1,5

内存变化过程：
数组初始化时，在堆中分配内存存储数组数据[1,2,3,4,5]
main方法的栈帧中，nums变量存储该数组的堆内存地址（假设地址为0x100）
调用change()方法时，将nums的值（0x100）复制到方法参数的nums变量（新栈帧中的新地址）
通过复制的地址0x100，仍然可以找到并修改堆中的原始数组
方法调用结束后，change方法的栈帧销毁，但堆中的数据已被修改
📌 关键点：
基本类型传递值，对象类型传递引用副本
栈中存储的是引用（地址），堆中存储实际对象数据
方法调用不会创建新数组对象，只是复制了对象地址
通过复制的地址仍然可以修改原始对象内容

传递引用数据类型时，传递的是地址值，形参的改变，影响实际参数的值。

感谢您的观看，您的支持是我更新最大的动力！
不作溢美之词，不作浮夸文章，此文与功名进取毫不相关也！与大家共勉！