java学习笔记之方法——2021/03/12

一、方法的重载

1、重载的概念

在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可。（参数顺序不同也可以构成重载。）

2、重载的特点

1. 与返回值类型无关，只看参数列表，且参数列表必须不同（参数个数或参数类型）。调用时，根据方法参数列表的不同来区别。
2. 示例

public int add(int x,int y){
	return x + y;
}

public double add(double x,double y){
	return x + y;
}

public int add(int x,int y,int z){
	return x + y + z;
}

3、 练习

//Test.java
public void mOL(int i){
	System.out.println(i * i);
}

public void mOL(int x,int y){
	System.out.println(x * y);
}

public void mOL(String s){
	System.out.println(s);

//main中调用
Test t = new Test();
t.mOL(2);
t.mOL(2,3);
t.mOL("方法重载");

4、方法的可变个数的参数

体会可变个数的形参

public class Person3(){
	public void printInfo(String[] args){//能够打印的信息都来源于方法的参数也就是形参的传递
		//可能给方法要传递不同的参数。在这种情况下，不知道要给方法传递多少个参数（姓名、性别、年龄，也可能是身份证号，家庭住址等等）
		//第一个方法：用数组的方式来传递可变个数的参数
		//如果没有参数，就要定义一个空数组或者是null
		for(int i = 0; i <args.length; i++){
			System.out.println(args[i]);
		}

		
		//第二个方法：用java特有的...的方式来传递可变个数的参数，这种参数在使用时与数组的使用相同
		//如果没有参数可以不填
		//...表示可以传递0-多个参数
		public void printInfo1(String... args){
			for(int i = 0; i <args.length; i++){
				System.out.println(args[i]);
			}
		}
	}
}

public class Test5{
	public static void main(String[] args){
		//方法一的调用
		Person p3 = new Person();
		String[] ss = new String[]{"zhangsan","11"};
		p3.printInfo(ss);

		//方法二的调用1
		p3.printInfo1("lisi","23","男");
		
		//方法二的调用2
		String[] ss2 = new String[]{"北京市xxxxxxx"，“13113222222”，“1521066666”};
		p3.printInfo(ss2);
	}
}

说明：

1. 可变参数：方法参数部分指定类型的参数个数是可变多个
2. 声明方式：方法名（参数的类型名…参数名）
3. 可变参数方法的使用与方法参数部分使用数组是一致的
4. 方法的参数部分有可变形参，需要放在形参声明的最后printInfo1(int d,String... args)

二、方法的参数传递

1、方法

必须有其所在类或对象调用才有意义。若方法含有参数
- 形参：方法声明时的参数
- 实参：方法调用时实际传给形参的参数值

2、 java的实参值如何传入方法：

**java里方法的参数传递方式只有一种：值传递。**即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

3、 示例

public class Test6{
	public static void swap(int i){
		i = 6;
		System.out.println("swap方法中参数i的值：" + i);
	}


	public static void main(){
		int a = 0;
		swap(a);
		System.out.println("main方法中a的值：" + a)；
	}
}

输出结果i=6，a=0。

1. 先执行的int a = 0，在栈中开辟了一块内存，地址是xxxxx，存的值是0
2. 调用swap方法，执行int i部分，在栈中开辟一块内存，地址是yyyyy，值就是从a复制过来的值，为0。
3. 执行swap方法体里的代码，i = 6，把i的值改为6，最终i在栈中的值就是6

4、方法的参数传递之引用对象

//DataSwap.java
public class DataSwap{
	public int a;
}

//Test7.java
public class Test{
	public static void swap(DataSwap ds1){
		ds1.a = 6;
		System.out.println("在swap方法中，ds1.a的值是：" + ds1.a);
	}

	public static void main(String[] args){
		DataSwap ds = new DataSwap();
		System.out.println("调用swap方法之前，ds.a的值是：" + ds.a);
		swap(ds);
		System.out.println("调用swap方法之后，ds.a的值是：" + ds.a);
	}
}

输出：
调用swap方法之前，ds.a的值是：0
在swap方法中，ds1.a的值是：6
调用swap方法之后，ds.a的值是：6

1. DataSwap ds = new DataSwap(),把newDataSwap存到了堆内存中，地址BE2500
2. ds引用对象存到栈中，地址是AD9500，值是new DataSwap()对象在堆中的地址BE2500
3. 调用swap方法，给ds1引用对象保存到栈中，地址是AD9600，存的值来源于实参（ds），也就是ds的栈中存的值，这个值实际上就是之前new DataSwap（）对象在堆中的内存地址。
   
   到第3步的时候，实际上，ds、ds1其实都是指向同一个对象，这个对象就是在堆内存中地址是BE2500上保存的对象。
   在这个例子中，最后的结果是ds和ds1操作实际上是同一个对象。

5、方法的参数传递小结：

1. 如果方法的形参是基本数据类型，那么实参（实际的数据）向形参传递参数时，就是直接传递值，把实参的值赋值给形参。
2. 如果方法的对象是形参，那么实参（实际的对象），向形参传递参数的时候，也是把值传给形参，这个值是实参在栈内存中的值，也就是引用对象在堆内存中的地址
3. 基本数据类型都是保存在栈内存中，引用对象在栈内存中保存的是引用对象的地址，那么方法的参数传递是传递值（是变量在栈内存当中的值）