Java 方法（方法的调用机制、方法的传参机制）

方法

方法就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。 当需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。

修饰符 返回值类型 方法名 （参数列表）｛ 
    代码... 
    return 返回值; 
｝

定义格式解释：

• 修饰符： 用于控制方法使用的范围，权限修饰符、静态修饰符、final修饰符 。
• 返回值类型：表示方法运行的结果的数据类型，方法执行后将结果返回到调用者。一个方法只能有一个返回值。void表示没有返回值。
• 方法名：为我们定义的方法起名，满足标识符的规范，用来调用方法。
• 参数列表： 方法在运算过程中的未知数据，调用者调用方法时传递。可以没有参数，也可以有多个参数，用逗号隔开。参数类型可以为任意类型，可以使用基本类型和引用类型。当调用该方法时，传入的参数要与参数列表顺序相同或者兼容的类型的参数。
• return：将方法执行后的结果带给调用者，方法执行到 return ，整体方法运行结束。如果没有返回值，该语句不是必须的，但是也可以写return，当代码执行到的时候，表示方法结束。

方法必须定义在一类中方法外，不能定义在另一个方法的里面，定义方法需明确返回值类型和参数列表，返回值类型，必须要和 return 语句返回的类型相同，否则编译失败。不能在 return 后面写代码， return 意味着方法结束，所有后面的代码永远不会执行，属于无效代码。

方法定义时的参数叫形参，方法调用时的参数叫实参，实参和形参的类型要一直或兼容，个数、顺序必须一致。

方法不能嵌套定义！！

同一个类中的方法可以直接调用，跨类调用需要通过对象名调用，比如对象名.方法名(参数);，方法的调用还和访问修饰符相关。

public class Method01 {
    public static void main(String[] args) {
        // 方法的使用
        // 定义好方法后，如果不调用，则不会执行
        // 先创建对象，然后进行调用
        Person p1 = new Person();
        p1.speak(); // 这里调用方法
        p1.cal01();
        p1.cal02(1000); // 传入的是1000，则n=1000
        p1.cal02(5); // 一个对象的方法可以调用多次

        // 将该方法返回的int值 赋值给 sum 变量
        int sum = p1.getSum(10, 20); // 传参是10,20，则n = 10, m = 20，使用int sum来接收方法的返回值
        System.out.println("getSum方法得到的返回值为：" + sum);
    }
}

class Person {
    String name;
    int age;

    // 方法(成员方法)
    // 输出“我是一个好人”
    // public：表示方法是公开的
    // void：表示方法没有返回值
    // speak：方法名
    // ()：形参列表
    // {}：方法体，就是要执行的代码
    public void speak() {
        System.out.println("我是一个好人");
    }

    // 计算1+...+100
    public void cal01() {
        // 进行循环
        int res = 0;
        for (int i = 1; i <= 100; i++) {
            res += i;
        }
        System.out.println("cal01计算结果：" + res);
    }

    // 计算1+...+n
    // (int n)：形参列表，表示当前方法可以传入一个int的值
    public void cal02(int n) {
        int res = 0;
        for (int i = 1; i <= n; i++) {
            res += i;
        }
        System.out.println("cal02计算结果：" + res);
    }

    // 计算两个数的和，并返回
    // public后面的int：表示方法执行后，返回给调用者一个int的值
    // (int n, int m)：有两个形参，表示当前方法可以接收两个参数
    // return res;：表示把res的值返回给调用者
    public int getSum(int n, int m) {
        int res = m + n;
        return res;
    }
}

方法的调用机制

(参考上面代码)

1. 当程序执行到方法时，就会开辟出一个独立的空间(栈空间)
2. 当方法执行完毕，或者执行到return语句时，就会返回
3. 返回到调用的地方
4. 返回后继续执行方法后面的代码
5. 当main方法执行完毕后，程序就退出了

方法的传参机制

public class MethodParameter01 {
    //编写一个 main 方法
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        //创建 AA 对象 名字obj 
        AA obj = new AA();
        obj.swap(a, b);//调用 swap
        System.out.println("\nmain 方法 a=" + a + " b=" + b);//a=10 b=20
    }
}

class AA {
    public void swap(int a, int b) {
        System.out.println("\na 和 b 交换前的值\na=" + a + "\tb=" + b);//a=10 b=20 
        // 完成了 a 和 b 的交换 
        int tmp = a;
        a = b;
        b = tmp;
        System.out.println("\na 和 b 交换后的值\na=" + a + "\tb=" + b);//a=20 b=10 
    }
}

基本数据类型传递的是值(值拷贝)，形参的任何改变不影响实参

当执行obj.swap(a, b);的时候会进入swap方法中，在该方法中，该方法的参数a和b完成了值的交换，但是main方法中的a和b并没有交换，所以输出如下：

---

public class MethodParameter02 {
    //编写一个 main 方法
    public static void main(String[] args) {
        B b = new B();
        int[] arr = {1, 2, 3};
        b.test(arr);  //调用方法
        System.out.println(" main 的 arr 数组 ");

        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
    }
}

class B {
    public void test(int[] arr) {
        arr[0] = 200;   //修改元素 
        // 遍历数组 
        System.out.println(" test100 的 arr 数组 ");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
    }
}

引用类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参！

方法?重载

java 中允许同一个类中，多个同名方法的存在，但要求形参列表不一致。只要它们的参数列表不同即可，与修饰符和返回值类型无关。 比如：System.out.println(); out 是 PrintStream 类型。

• 参数列表： 个数不同，数据类型不同，顺序不同。如果参数列表类型、顺序、数量相同，参数名不同，不构成重载。
• 返回类型：如果参数列表相同，方法名相同，返回值不同，不构成重载。
• 重载方法调用： JVM通过方法的参数列表，调用不同的方法。

public class OverLoad01 {
    public static void main(String[] args) {
        MyCalculate mc = new MyCalculate();
        System.out.println(mc.calculate(1, 2));        // 打印结果：3
        System.out.println(mc.calculate(3, 4.5));    // 打印结果：7.5
        System.out.println(mc.calculate(1.2, 2));    // 打印结果：3.2
        System.out.println(mc.calculate(1, 4, 7));    // 打印结果：12
    }
}

// 这个类的四个calculate方法构成了重载
// 方法名一样，参数列表的类型不一样
class MyCalculate {
    // 两个整数的和
    public int calculate(int n1, int n2) {
        return n1 + n2;
    }

    // 这个方法和上面的方法不构成重载，因为参数列表的类型相同
//    public int calculate(int a1, int a2) {
//        return a1 + a2;
//    }

    // 一个整数和一个浮点数的和
    public double calculate(int n1, double n2) {
        return n1 + n2;
    }

    // 一个浮点数和一个整数的和
    public double calculate(double n1, int n2) {
        return n1 + n2;
    }

    // 三个整数的和
    public int calculate(int n1, int n2, int n3) {
        return n1 + n2 + n3;
    }
}

可变参数

Java允许将同一个类 多个同名 同功能 但 参数个数不同的方法，封装成一个方法。在JDK1.5之后，如果定义一个方法需要接收多个参数，并且多个参数类型一致，可以对其简化成如下格式：

修饰符 返回值类型 方法名(参数类型... 形参名){ }

public class ChangeParam01 {
    // 计算两个数的和，三个数的和，四个数的和，五个数的和....
    // 可以使用方法重载
    public int sum(int n1, int n2) {return n1 + n2;}
    public int sum(int n1, int n2, int n3) {return n1 + n2 + n3;}
    public int sum(int n1, int n2, int n3, int n4) {return n1 + n2 + n3 + n4;}

    // 上面三个方法名称相同，功能相同，只有参数个数不同，可以使用可变参数优化
    // int... 表示该参数是可变参数，类型是int，可以接收多个int类型的参数(0-n个参数)
    public int sums(int... nums) {
        // 使用可变参数时，可以当做数组使用，所以nums是一个数组
        System.out.println("接收的参数个数为：" + nums.length);
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        return sum;
    }

    public static void main(String[] args) {
        ChangeParam01 cp = new ChangeParam01();
        int res = cp.sums(0, 1, 2, 3, 4, 5, 6, 7);
        System.out.println("返回的结果为：" + res);

        int[] arr = {3, 6, 9};
        // 可变参数的实参可以传入数组
        int res2 = cp.sums(arr);
        System.out.println("res2的结果：" + res2);
    }
}

• 使用可变参数时，参数可以当做数组使用，同样是数组，但是在调用这个带有可变参数的方法时，不用创建数组，直接将多个相同类型的元素作为实际参数进行传递。
• 在jvm编译成class文件时，会将这些元素封装到一个数组中，然后再进行传递。这些动作都在编译.class文件时，自动完成了。
• 可变参数的实参可以为数组。
• 可变参数可以和普通类型的参数放在形参列表，但必须保证可变参数在最后。
  • 例如：public void sums(String str, double... nums) {}
• 一个形参列表中只能出现一个可变参数

作用域

在Java中，主要的变量就是成员变量和局部变量。

在同一个类中，成员变量和局部变量可以重名，访问时遵循就近原则；但是在同一个作用域中，比如在同一个成员方法中，两个局部变量不能重名。

默认值：

• **成员变量：**有默认值，可以直接使用。
• **局部变量：**没有默认值，需要先赋值后使用。

生命周期：

• **成员变量：**生命周期较长，伴随着对象的创建而创建，随着对象的销毁而销毁。
• **局部变量：**生命周期较短，伴随着他的代码块的执行而创建，随着代码块的结束而销毁(就是在一次方法的调用中开始，方法结束，变量随之销毁)。

作用域：

• **成员变量：**作用域为整个类，可以本类使用，或者其他类使用(通过对象调用)。
• **局部变量：**只能在本类中应对的方法(代码块)中使用。

修饰符：

• **成员变量：**可以加修饰符。
• **局部变量：**不可以加修饰符。

构造方法

构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。

[修饰符] 方法名(形参列表){
    方法体;
}

• 构造器的修饰符可以默认，也可以是 public protected private
• 构造器没有返回值，也不需要void
• 方法名和类名字必须相同
• 参数列表 和 成员方法一样的规则，既可以定义参数，也可以不定义参数
• 在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。
• 构造器是完成对象的初始化，并不是创建对象
• 一个类可以定义多个不同构造器，是可以重载的。
• 如果没有定义构造器，系统会自动给出一个默认无参的构造器，也叫做默认构造器
• 如果定义了构造器，默认的构造器会被覆盖，除非手动创建一个无参构造

package object;

public class Constructor {
    public static void main(String[] args) {
        // 使用两种不同的构造器
        Person p = new Person("张三", 25);
        System.out.println("name：" + p.name);
        System.out.println("age：" + p.age);

        Person p1 = new Person("李四");
        System.out.println("name：" + p1.name);
        System.out.println("age：" + p1.age);
    }
}

class Person {

    String name;
    int age;

    // 构造器没有返回值，也不需要写void
    // 构造方法的方法名必须和类名一样
    // 形参列表和其他方法一样
    public Person(String pName, int pAge) {
        System.out.println("构造器执行了....");
        name = pName;
        age = pAge;
        System.out.println("构造器完成了对属性的初始化...");
    }

    // 构造器可以重载
    public Person(String pName) {
        name = pName;
    }

    // 如果我们定义了构造器，则默认构造器会被覆盖，如果需要，可以手动创建无参构造
    // 默认的无参构造访问修饰符也是默认的
    public Person() {

    }
}

可以使用javap工具反编译，能看到反编译后的结果中有定了一个 访问修饰符为默认 方法名为类名的方法。

对象创建的流程

class Person {
    String name;
    int age = 90;

    // 构造器
    Person(String n, int a) {
        name = n;
        age = a;
    }
}

// 对象创建时发生了什么
Person p = new Person("张三", 20);

1. 加载Person类信息(Person.class)，只会加载一次，不会重复加载
2. 在堆中分配空间(地址)
3. 完成对象的初始化(默认初始化 age = 0 → 显式初始化 age = 90 → 构造器初始化 age = 20)
4. 把对象在堆中的地址赋值给p(对象名)

this关键字

Java虚拟机会给每个对象分配this， 代表所在类的当前对象的引用（地址值），即对象自己的引用。方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁，方法中只有一个变量名时，默认也是使用 this 修饰，可以省略不写。

class Dog {
    String name;
    int age;

    // 不使用this，name则等于该方法中的name（就近原则）
//    public Dog(String name, int age){
//        name = name;
//        age = age;
//    }

    // 使用this 相当于是Dog对象.name，指的是Dog类中的属性，而没有加this的name指的是方法中的name
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

• this关键字可以访问本类的属性、方法、构造器

• this用于区分当前类的属性和局部变量

• 访问成员方法的语法：this.方法名(参数列表);

• 访问构造器语法：this(参数列表);，只能在构造器中使用(并且必须放在第一行)

• this不能再类定义的外部使用，只能在类定义的方法中使用