Java 方法详解

Java 方法 是类或对象的行为特征的抽象，方法是类或对象的最重要的组成部分。Java中的方法不能独立存在，所有的方法都必须定义在类里。方法在逻辑上要么属于类，要么属于对象！

方法所属性

• 方法不能独立定义，方法只能定义在类里
• 从逻辑意义上来看，方法要么属于类本身，要么属于该类的一个对象
• 永远不能独立执行方法，执行方法必须使用类或者对象作为调用者

---

方法的参数传递机制

就是将实际参数的复制品传入方法内，而参数本身不会受到任何影响。

基本类型传递

例：

public class Main {

    /**
     * 第三女神
     *
     * @param args
     */
    public static void main(String[] args) {

        //定义变量
        int num = 101;

        //调用方法
        function(num);

        //结果还是输出101
        System.out.println(num);
    }

    /**
     * 定义的一个方法
     *
     * @param number 形参
     */
    public static void function(int number) {
        
        //执行运算
        number += 10;

        //这里输出111
        System.out.println(number);
    }
}

从上面的代码例子可以看出，调用了方法，进入方法进行运算，结果还是输出101，这就是所谓的参数本身不会受到任何影响！

讲述：
当程序执行function方法时，系统会进入function方法，并将变量num变量的副本带进去，注意，是num的复制品，进入方法后，也就产生了2个变量，示意图如下：

当在main中调用了function方法时，main方法此时没有结束，因此，系统会给main和function分配两个栈区，用于保存它们各自的局部变量，main方法中的num变量作为参数传入function方法中，实际上试试在function方法栈区重新产生了一个变量，并将main中的num赋值该给function方法栈区中的number参数，即 对function中的number做初始化！此时，系统存在num和number两个变量！分别存放在不同的栈区！

当在function方法中执行+=10操作后，只是在function栈区中为number执行了操作，而没有对main栈区中的num做修改！

---

引用类型传递

基本类型很好理解，可是引用类型呢？来试一下！

例：
先来创建一个People类：

public class People {

    private String name;
    private int age;

    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

接下来new对象，对ta进行操作：

public class Main {

    /**
     * 第三女神
     *
     * @param args
     */
    public static void main(String[] args) {

        //创建一个对象
        People people = new People("第三女神", 25);

        //调用改变年龄方法
        changeAge(people);

        //输出年龄
        System.out.println(people.getAge());
    }

    /**
     * 改变年龄方法
     *
     * @param people
     */
    private static void changeAge(People people) {
        people.setAge(26);
    }

}

运行结果竟然是：26 ！

不应该只是操作了一个复制品吗？

我们来看一下在内存中的示意图：

在Main创建好People对象之后，在内存中是这样的，创建好的people指向了堆内存中的People对象！

接下来要调用 changeAge 方法，在内存中又开辟了 changeAge 方法栈区：

changeAge方法调用后，把变量赋值给形参，他们都指向了同一个内存地址，调用setAge后，重新为age赋值为了26，在堆内存中的People也就重新赋了值，所以会输出26，和基本变量操作是不一样的！

如果还没懂没关系，我再举一个现实的例子：

有一个袋子里放了100万RMB（相当于在堆内存中放置了这100万RMB），假设你是Main，你让我从这个袋子里拿走20万RMB（相当于调用changeAge方法），之后你要看看袋子里还剩下多少RMB，发现还剩下80万RMB，其实就是这样的一个过程！

请不要评论 可以不可以给我100W，我要做实验相关的！我会告诉你：

---

形参个数可变

在JDK1.5之后，Java允许定义可变个数的参数，从而来允许指定不确定个数的形参。在定义方法时，只需要在最后形参中的变量类型后增加（…）即可，就可以表明该方法可以接受多个参数值，多个参数值会被当成数组的形式传入。

public class Main {

    /**
     * 第三女神
     *
     * @param args
     */
    public static void main(String[] args) {
        chestnut(5800337, "现在我还有", "美金");
    }

    /**
     * 例子
     * @param num
     * @param value
     */
    private static void chestnut(int num, String... value) {
        System.out.println(value[0] + num + value[1]);
    }

}

打印输出：

值得注意的是，一个方法中最多只能有一个可变的形参，并且位于方法中最后一个。

---

递归方法

递归，简单理解就是自己调用自己，类似于一种循环，简单举例：

public class Main {

    /**
     * 第三女神
     *
     * @param args
     */
    public static void main(String[] args) {
        printfStar(10);
    }

    private static void printfStar(int num) {

        for (int i = 0; i < num; i++) {
            System.out.print("*");
        }

        System.out.println();

        if (num > 1) {
            
            //调用自己
            printfStar(num - 1);
        }
    }

}

打印输出：

有什么用呢？下一篇详细讲道！
关个注，点个赞，评论一下，好人平安！