重生之我发现成员方法的秘密

       我们需要很多方法去解决问题，但是一个主函数中，写很多的方法是冗杂，效率慢的，而且比较容易使程序崩溃，所以我们使用类中的成员方法，在主函数中调用，提高了方法的复用性，而且可以将实现的细节封装起来，然后供其他用户调用。

快速入门

public class Method01 { 

  public static void main(String[] args) { 
//方法使用 
//1. 方法写好后，如果不去调用(使用)，不会输出 
//2. 先创建对象 ,然后调用方法即可 
    Person p1 = new Person(); 
    p1.speak(); //调用方法 
    p1.cal01(); //调用 cal01 方法 
    p1.cal02(5); //调用 cal02 方法，同时给 n = 5 
    p1.cal02(10); //调用 cal02 方法，同时给 n = 10 
//调用 getSum 方法，同时 num1=10, num2=20 
//把 方法 getSum 返回的值，赋给 变量 returnRes 
    int returnRes = p1.getSum(10, 20); 
    System.out.println("getSum 方法返回的值=" + returnRes); 
        } 
    } 
class Person { 
    String name; 
    int age; 
//方法(成员方法) 
//添加 speak 成员方法,输出 “我是一个好人” 
//老韩解读 
//1. public 表示方法是公开 
//2. void ： 表示方法没有返回值 
//3. speak() : speak 是方法名， () 形参列表 
//4. {} 方法体，可以写我们要执行的代码 
//5. System.out.println("我是一个好人"); 表示我们的方法就是输出一句话 
    public void speak() { 
        System.out.println("我是一个好人"); 
    } 
//添加 cal01 成员方法,可以计算从 1+..+1000 的结果 
    public void cal01() { 
//循环完成 
        int res = 0; 
        for(int i = 1; i <= 1000; i++) { 
        res += i; 
        } 
    System.out.println("cal01 方法 计算结果=" + res); 
    } 
//添加 cal02 成员方法,该方法可以接收一个数 n，计算从 1+..+n 的结果 
//老韩解读 
//1. (int n) 形参列表， 表示当前有一个形参 n, 可以接收用户输入 
    public void cal02(int n) { 
//循环完成 
        int res = 0; 
        for(int i = 1; i <= n; i++) { 
        res += i; 
        } 
    System.out.println("cal02 方法 计算结果=" + res); 
    } 
//添加 getSum 成员方法,可以计算两个数的和 
//老韩解读 
//1. public 表示方法是公开的 
//2. int :表示方法执行后，返回一个 int 值 
//3. getSum 方法名 
//4. (int num1, int num2) 形参列表，2 个形参，可以接收用户传入的两个数 
//5. return res; 表示把 res 的值， 返回 
    public int getSum(int num1, int num2) { 
        int res = num1 + num2; 
        return res; 
        } 
    }

看如上这个代码：

我们在类中创建不同的成员方法，成员方法也有访问修饰符。

成员方法有一定格式。

在主方法中调用也有规则。

成员方法

访问修饰符 返回数据类型 方法名（形参列表 .. ） {// 方法体

                                语句；

                        return 返回值;

                    }

1) 形参列表：表示成员方法输入 cal(int n) ， getSum(int num1, int num2)

2) 返回数据类型：表示成员方法输出 , void 表示没有返回值

3) 方法主体：表示为了实现某一功能代码块

4) return 语句不是必须的。

注意：

1. 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型 的参数。

2.实参和形参的类型要一致或兼容、个数、顺序必须一致。

3.方法不能嵌套定义。

4.一个方法最多有一个返回值。

5.形参列表如： (int num1, int num2)，代表可以传入用户输入的两个数，供成员方法使用。

参数类型可以是任何类型，包含基本类型和引用类型。

6. 返回类型可以为任意类型，包含基本类型或引用类型 ( 数组，对象 )。

7.如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值 ; 而且要求返回值类型必须和 return 的值类型一致或兼容。

说到这里有一个很混乱的点：实参和形参

实参和形参的区别

形参就是非数字的字符，实参是有确切数字的。

在调用函数过程中，系统会把实参的值传递给被调用函数的形参。或者说，形参从实参得到一个值。该值在函数调用期间有效，可以参加该函数中的运算。

但是形参的本质是一个名字，不占用内存空间。

这篇文章从内存分配机制来介绍实参与形参，可以参考。

JAVA基本语法：形参与实参的区别与联系_对于基本数据类型的参数,形式参数的改变会影响实际参数的值吗?-CSDN博客

方法调用

方法调用机制

方法调用细节

同一个类中的方法调用：直接调用即可。

跨类中的方法 A 类调用 B 类方法：需要通过对象名调用。

如图：

class A {
public void m1() {
//创建 B 对象, 然后在调用方法即可
    System.out.println("m1() 方法被调用");
    B b = new B();
    b.hi();
    System.out.println("m1() 继续执行:)");
    }
}
class B {
    public void hi() {
    System.out.println("B 类中的 hi()被执行");
    }
}

成员方法传参机制

基本数据类型的传参机制

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("main 方法 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
    }
}

这样一个代码他的运行机制如下图所示：

1.在主方法创建对象，调用方法，然后进行方法。

2.在swap方法中，ab进行交换，此时a=20，b=10

3.但是在主方法中进行swap后再输出ab的值，却是没有swap，a还是10，b还是20

引用数据类型的传参机制

public class MethodParameter02 {
    //编写一个 main 方法
    public static void main(String[] args) {
    //测试
    B b = new B();
    // int[] arr = {1, 2, 3};
    // b.test100(arr);//调用方法
    // System.out.println(" main 的 arr 数组 ");
    // //遍历数组
    // for(int i = 0; i < arr.length; i++) {
    //     System.out.print(arr[i] + "\t");
    // }
    // System.out.println();
    //测试
    Person p = new Person();
    p.name = "jack";
    p.age = 10;
    b.test200(p);
    //测试题, 如果 test200 执行的是 p = null ,下面的结果是 10
    //测试题, 如果 test200 执行的是 p = new Person();..., 下面输出的是 10
    System.out.println("main 的 p.age=" + p.age);//10000
    }
}
class Person {
    String name;
    int age;
    }
class B {
    public void test200(Person p) {
        //p.age = 10000; //修改对象属性
        //思考
        p = new Person();
        p.name = "tom";
        p.age = 99;
        //思考
        //p = null;
        }
    //B 类中编写一个方法 test100，
    //可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化
    public void test100(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();
    }
}

问：

B 类中编写一个方法 test100 ，可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化？

B 类中编写一个方法 test200 ，可以接收一个 Person(age,sal) 对象，在方法中修改该对象属性，看看原来的对象是否变化？

答案是都会变化，这是与基本数据了类型截然不同的。

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

还有其他小问题，比如说编写一个方法 copyPerson，可以复制一个 Person 对象，返回复制的对象。克隆对象， 注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同，他们是否为同一个对象。

答案是否定的。

总结

成员方法最主要的是如何调用，在调用的时候又有很多细节，同时两个不同的传参机制也是值得去琢磨的。如果不认真敲打几个题，知识只能左耳朵进右耳朵出。

有没有觉得，看代码才是学习代码的最好的方法。