Java 方法 (Java 入门笔记)

目录

• 导言
• 无参数的方法
  • 定义
  • 调用
• 带参数的方法
  • 定义
  • 调用
  • 形参和实参
• 带返回值的方法
  • 定义
  • 调用
• 方法的重载
  • 注意
• 方法的内存分配
  • 方法调用时
  • 基本数据类型
  • 引用数据类型
• 方法的传参
  • 方法传递基本数据类型时
  • 方法传递引用类型数值时
• 可变参数
• 递归
• 练习

导言

方法：程序中最小的执行单元。

重复的代码、具有独立功能的代码可以抽取在方法当中。

把重复的代码写在方法中，提高代码复用性&可维护性。

把一些代码打包在一起的过程，就是方法定义；方法定义后需要手动调用，就是方法调用。

当写一个方法的时候，需要问自己三个问题：

1. 这个方法需要做什么（决定方法体）；

2. 这个方法的运行需要什么（决定形参）；

3. 调用处是否需要方法的运行结果（决定是否需要返回值）。

注意：

1. 不调用就不执行；
2. 方法都是平级关系，顺序随意（但规定主方法在先）；
3. 不能嵌套定义方法。

---

无参数的方法

定义

命名规则：小驼峰（首字母小写）

public static void 方法名(){
    方法体;
}

写在 main 方法的外面，类的里面。

调用

	方法名();

写在 main 方法的里面。

例：

public class Demo {
    public static void main(String[] args) {
        getSum();
    }

    public static void getSum() {
        int a = 3;
        int b = 5;
        System.out.println(a + b);
    }
}

//输出：8：：

---

带参数的方法

运用场景：方法需要其他东西来实现功能的话，就使用带参数的方法。

定义

public static void 方法名(参数1, 参数2){//在括号里初始化，如(int x, int y)
    方法体;
}

调用

	方法名(参数1, 参数2);//值、变量。

调用的时候，形参和实参必须保持一致。

例：

public class Demo1 {
    public static void main(String[] args) {
        getSum(3,5);
    }

    public static void getSum(int x, int y) {
        System.out.println(x + y);
    }

}

//输出：8

形参和实参

形参：方法定义中的参数（形式参数）

实参：方法调用中的参数（实际参数）

---

带返回值的方法

返回值：方法运行的最终结果。

运用场景：在调用处取得方法的结果。

定义

public static 返回值数据类型 方法名(参数){
    方法体;
    return 返回值;
}

return 语句后面不可以写代码，该语句其他作用详见这里。

注：不带返回值的方法最后也可以写 return;，但是后面必须是空的。

调用

直接调用

	方法名(实参);

赋值调用

	数据类型 变量名 = 方法名(实参);

输出调用

	System.out.println(方法名 (实参));

例：

public class Practice {
    public static void main(String[] args) {
        System.out.println(compareArea(2,3,4,5));
    }

    //求面积
    public static double getArea(double length, double width){
        double area = length * width;
        return area;
    }

    //比大小
    public static String compareArea(double length1, double width1, double length2, double width2){
        double area1 = getArea(length1, width1);
        double area2 = getArea(length2, width2);
        String result;
        if (area1 > area2){
            result = ">";
        }else if (area1 == area2){
            result = "=";
        }else{
            result = "<";
        }
        return result;
    }
}

输出：<

---

方法的重载

同一个类当中，定义多个方法名相同，但参数不同（个数不同、类型不同、顺序不同）的方法。

即“同类同名不同参”。

注意

1. 相同功能的方法一般用相同的名字
2. 多个方法是否为重载关系与参数有关，与返回值无关；
3. 顺序不同构成重载，但是不建议。

---

方法的内存分配

Java 的内存分配看这里。

方法调用时

方法调用后直接进入栈执行。

原则：先进后出（最先进栈的最晚走，最晚进栈的最早走）。

基本数据类型

基本数据类型：整形、浮点、boolean、字符。

位置：放在栈里。

存储内容：变量存储真实数据。

特点：赋值给其他变量时，给的是真实的值。若改变赋值后的结果，原变量不变。

引用数据类型

引用数据类型：基本数据类型以外的（都是 new 出来的）

位置：new 出来的都在堆里。

存储内容：变量存储地址值，数据在其他空间。

（因为是引用其他空间的数据所以叫做“引用数据类型”）

特点：赋值给其他变量时，给的是地址值。若改变赋值后的结果，原变量会改变。

---

方法的传参

方法传递基本数据类型时

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

public class Demo5 {
    public static void main(String[] args) {
        int num = 100;
        System.out.println(num);//改变形参前
        change(num);
        System.out.println(num);//改变形参后
    }

    public static void change(int num) {
        num = 200;
    }
}

/*
   输出:
   100
   100
 */

方法传递引用类型数值时

传输引用数据类型时，传输时的是地址值。形参的改变会同步影响到实际参数的值。

public class Demo6 {
    public static void main(String[] args) {
        int[] arr = {100};
        System.out.println(arr[0]);//改变形参前
        change(arr);
        System.out.println(arr[0]);//改变形参后
    }

    public static void change(int[] arr){
        arr[0] = 200;
    }
}

/*
   输出:
   100
   200
 */

---

可变参数

方法可以接受不定数量的参数，用于处理参数数量不确定的情况。

本质是一个数组，名字是声明里定义的可变参数名字。

定义：在方法声明中，指定的参数类型后面加 ...。

例：

public class Demo7 {
    public static void main(String[] args) {
        test(1, 22, 333);
    }

    public static void test(int... num){//是数组所以用遍历
        for (int i : num) {
            System.out.println(i);
        }
        for (int i = 0; i < num.length; i++) {
            System.out.println(num[i]);
        }
    }
}

/*
  输出
  1
  22
  333
  1
  22
  333
 */

---

递归

某方法调用它自己。

需要包括两个部分：

1. 递归头：边界条件，即什么时候不调用自身。（没有递归头会死循环）
2. 递归尾：什么时候调用自身。

例：

public class Demo8 {
    public static void main(String[] args) {
        System.out.println(factorial(5));//输出阶乘.
    }

    public static int factorial(int num) {
        if (num == 1) {//递归头 (结束条件)
            return num;
        } else {//递归尾 (调用条件)
            return num * factorial(num - 1);
        }
    }
}

//输出: 120

流程图：

如果没有条件边界，栈里面会无限调用自身从而栈溢出。

递归调用自身会占用很多空间，所以能不用递归就不用递归。

重复次数少的可以用递归，但是重复次数多就不建议。

练习

鸽了，等我考完四级再补上。

碎碎念：之前用 Typora 写文档的时候写道一般发现旁边的大纲没变化了，本想着应该关掉之后重新再打开就好，于是选择继续写，写完之后关闭再打开却发现从大纲没变化的部分往后的内容都没有被保存，人直接麻了，现在已经换了一个 md 编辑器。🙏