2. 成员方法

2.1 格式

 class 类名 {
	返回值类型 成员方法名(形参列表) {
	成员方法体;
	}
 }
//类名：每个单词大写
//方法名：第二个单词起每个单词的首字母大写。

2.2 返回值类型

概念：返回值主要指从方法体内返回到方法体外的数据内容。

• 返回值类型主要指返回值的数据类型，可以是基本数据类型，也可以是引用数据类型。
• 当返回的数据内容是66时，则返回值类型写 int 即可
• 在方法体中使用return关键字可以返回具体的数据内容并结束当前方法，当返回的数据内容是66时，则方法体中写 return 66即可
• 当该方法不需要返回任何数据内容时，则返回值类型写void即可。

2.3 形参列表

概念：形式参数主要用于将方法体外的数据内容带入到方法体内部。

**格式：**语法格式如下：
（数据类型 形参变量名1, 数据类型 形参变量名2, …）

当带入的数据内容是"hello"时，则形参列表写 String s 即可

当带入的数据内容是66和"hello"时，则形参列表写 int i, String s 即可

若该方法不需要带入任何数据内容时，则形参列表位置啥也不写即可。

2.4 方法体

返回值类型 成员方法名(形参列表) {
	成员方法体;
	}

//自定义成员方法实现所有成员变量的打印
void show() {
    //成员方法和成员变量都属于类内部的成员，因此可以直接访问成员变量不需要再加引用.的前缀
    System.out.println("我是"+name+",我今年"+age);
}

2.5 方法的调用

引用变量名.成员方法名(实参列表);

实际参数列表主要用于对形式参数列表进行初始化操作，因此参数的个数、类型以及顺序都要完全一致。

实际参数可以传递直接量、变量、表达式、方法的调用等。

public class Point {
    int x;	//横坐标											//x,y为成员变量
    int y;	//纵坐标
    
    //3.定义一个成员方法来实现成员变量的打印
    void show() {
        System.out.println("横坐标是："+x+",纵坐标是："+y);
    }
    
    //自定义成员方法实现将姓名修改为参数指定的数值
    void setName(String s) {
        name=s;
    }
    //自定义成员方法实现将年龄修改为参数指定的数值
    void setAge(int i) {
        age=i;
    }
    //自定义成员方法同时实现将姓名和年龄修改为参数指定的数值
    void setNameAge(String s,int i) {							//()里的为形参
        name=s;													//s,i为局部变量
        age=i;
    }
    
    public static void main(String[] args) {
        
        //1.声明Point类型的引用指向Point的对象
        Point P=new Point();
        //打印成员变量的数值
        //System.out.println("横坐标是："+P.x+",纵坐标是："+P.y);
        P.show();
        
        System.out.println("------------------------------")
        //2.修改数值后
        P.x=3;
        P.y=5;
        //System.out.println("横坐标是："+P.x+",纵坐标是："+P.y);
        
        //调用方法的本质就是根据方法名跳转过去执行方法体，再跳转回来
        P.show;
        
        //通过成员方法的调用实现成员变量的修改
        P.setName("阿七");
        P.setAge(25);
        P.show();	//阿七	25
        
         //通过成员方法的调用实现成员变量的修改
         //P.setNameAge("阿七",25);						//()实参
        int ia=25;
        P.setNameAge("阿"+"七",ia);
        P.show();	//阿七	25
    }    
}

2.6 可变长的参数

返回值类型 方法名(参数的类型... 参数名)

方法参数部分指定类型的参数个数是可以改变的，也就是0~n个 .

一个方法的形参列表中最多只能声明一个可变长形参，并且需要放到参数列表的末尾。

//自定义成员方法实现可变长参数的使用，	看作是一维数组即可
void showArgument(int num,String... args) {
    System.out.println("num="+num);
    for(int i=0;i<args.length;i++) {
        System.out.println("第"+(i+1)+"个参数是："+arg[i]);
    }
   
    //通过成员方法的调用实现可变长参数的打印
    p.showArgument(12);		//12
    p.showArgument(15,"参数1");
    p.showArgument(15,"参数1","参数2");
}

public class Point {
    //成员变量
    int x;
    int y;
    //自定义成员方法实现可变长参数的使用
    void showArgument(int... args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("下标为" + i + "的元素为" + args[i]);
        }
    }
    public static void main(String[] args) {
        //声明Point类型引用指向Point类型的对象
        Point p=new Point();
        p.showArgument(1,2,3);
    }
}

注意：方法和方法是平行关系

2.7 局部变量和成员变量

1. 定义的位置：

   局部变量在方法体内部或者（ ）；

   成员变量在方法的外部，直接写在类里

2. 作用的范围：

   局部变量只可以在方法内部使用；

   成员变量整个类都可以使用；

3. 默认值：

   局部变量没有默认值，如果想要使用，需要手动赋值

   成员变量如果没用赋值，是有默认值的，规则和数组一样

4. 内存的位置：

   局部变量位于栈内存；成员变量位于堆内存

5. 生命周期：

   局部变量随着方法的进栈而诞生，随着方法的出栈而消失

   成员变量随着对象的创建而诞生，随着对象被垃圾回收而消失

2.8 方法的传参

2.8.1 过程

int max(int ia, int ib) { … … … } //成员方法

int a = 5; int b=6; int res = m.max(a,b); //main方法

1. 为main方法中的变量a、b、res分配空间并初始化。
2. 调用max方法，为max方法的形参变量ia、ib分配空间。
3. 将实参变量的数值赋值到形参变量的内存空间中。
4. max方法运行完毕后返回，形参变量空间释放。
5. main方法中的res变量得到max方法的返回值。
6. main方法结束后释放相关变量的内存空间。

2.8.2 注意事项

1. 基本数据类型的变量作为方法的参数传递时，形参变量数值的改变通常不会影响到实参变量的数值，因为两个变量有各自独立的内存空间；
2. 引用数据类型的变量作为方法的参数传递时，形参变量指向内容的改变会影响到实参变量指向内容的数值，因为两个变量指向同一块内存空间.
3. 当引用数据类型的变量作为方法的参数传递时，若形参变量改变指向后再改变指定的内容，则通常不会影响到实参变量指向内容的改变，因为两个变量指向不同的内存空间。

public class ArgumentTest {
    //自定义成员方法打印参数传入的整数数据
    //ia=ib=10
    void show1(int ia) {
        ia=200;
        System.out.println("ia的值=" + ia);   //10    200
    }
    //自定义成员方法打印参数传入的数组数据
    //引用数据类型，内存中存放的是地址
    void show2(int[] arr1) {
        arr1=new int[2];
        arr1[0]=200;
        System.out.println("show方法中：arr1[0]的数值是"+arr1[0]);  //200
    }

    public static void main(String[] args) {
        //1.声明Argument类型的引用指向该类型的对象
        ArgumentTest at = new ArgumentTest();
        //2.使用引用变量调用成员方法
        int ib = 10;
        at.show1(ib);
        System.out.println("ib的值="+ib);     //10
        System.out.println("------------------------------------");
        //3.调用show方法进行测试
        int[] arr2=new int[]{10,20};
        at.show2(arr2);
        System.out.println("show方法中：arr2[0]的数值是"+arr2[0]);  //200   10
    }
}

内存结构之栈区

• 栈用于存放程序运行过程当中所有的局部变量。一个运行的Java程序从开始到结束会有多次方法的调用。
• JVM会为每一个方法的调用在栈中分配一个对应的空间，这个空间称为该方法的栈帧。一个栈帧对应一个正在调用中的方法，栈帧中存储了该方法的参数、局部变量等数据。
• 当某一个方法调用完成后，其对应的栈帧将被清除。

传参的相关概念

• 参数分为形参和实参，定义方法时的参数叫形参，调用方法时传递的参数叫实参。
• 调用方法时采用值传递把实参传递给形参，方法内部其实是在使用形参。
• 所谓值传递就是当参数是基本类型时，传递参数的值，比如传递i=10，真实传参时，把10赋值给了形参。当参数是对象时，传递的是对象的值，也就是把对象的地址赋值给形参