CRainyDay

方法的重载
可变个数的形参的方法
Java的值传递机制

一.overload(重载)

1.重载要求:

  1. 同一个类中
  2. 方法名必须相同
  3. 方法的参数列表不同(①参数的个数不同②参数类型不同)
    注意: 方法的重载与方法的返回值类型没有关系!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//如下的四个方法构成重载
//定义两个int型变量的和
public int getSum(int i,int j){
return i + j;
}
//定义三个int型变量的和
public int getSum(int i,int j,int k){
return i + j + k;
}
//定义两个double型数据的和
public double getSum(double d1,double d2){
return d1 + d2;
}
//定义三个double型数组的和
public void getSum(double d1,double d2,double d3){
System.out.println(d1 + d2 + d3);
}
//如下两个方法不能与如上的几个方法构成重载
//public int getSum1(int i,int j,int k){//方法名必须相同
// return i + j + k;
//}
//public void getSum(int i,int j,int k){//与方法的返回值类型
// System.out.println(i + j + k);
//}

二.可变个数的形参的方法

可变个数的形参的方法(JDK5.0之后的特性):

  • 1.格式: 对于方法的形参: 数据类型 … 形参名
  • 2.可变个数的形参的方法与同名的方法之间构成重载
  • 3.可变个数的形参在调用时, 个数从0开始, 到无穷多个都可以
  • 4.使用可变多个形参的方法与方法的形参使用数组是一致的
  • 5.若方法中存在可变个数的形参, 那么一定要声明在方法形参的最后
  • 6.在一个方法中, 最多声明一个可变个数的形参
点击显/隐内容
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//如下四个方法构成重载
//在类中一旦定义了重载的可变个数的形参的方法以后, 下面的前两个方法可以省略
public void sayHello(){
System.out.println("hello world!");
}
public void sayHello(String str1){
System.out.println("hello " + str1);
}
//可变个数的形参的方法
public void sayHello(String ... args){
for(int i = 0;i < args.length;i++){
System.out.println(args[i] + "$");
}
}
public void sayHello(int i,String ... args){
//public void sayHello(String ... args,int i){//这样不对
System.out.println(i);
for(int j = 0;j < args.length;j++){
System.out.println(args[j] + "$");
}
}
public void sayHello1(String[] args){
for(int i = 0;i < args.length;i++){
System.out.println(args[i]);
}
}

三.Java的值传递机制

1.方法的参数传递

  1. 形参: 方法声明时, 方法小括号内的参数;实参: 调用方法时, 实际传入的参数的值
  2. 规则: Java中的参数传递机制: 值传递机制

①形参是基本数据类型的: 将实参的值传递给形参的基本数据类型的变量
②形参是引用数据类型的: 将实参的引用类型变量的值(对应的堆空间的对象实体的首地址值)传递给形参的引用类型变量.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//例1:
class Test1{
public static void main(String[] args) {
Test1 tt = new Test1();
int i = 10;
int j = 5;
System.out.println("i:" + i + " j:" + j);//i : 10 j : 5
/* //直接交换变量i与j的值
int temp = i;
i = j;
j = temp;
*/ tt.swap(i, j);//通过方法交换, 将i的值传递给m,j的值传递给n, 实际上i与j的值根本没有交换
System.out.println("i:" + i + " j:" + j);//i : 10 j : 5
}
//定义一个方法,交换两个变量的值
public void swap(int m,int n){
int temp = m;
m = n;
n = temp;
System.out.println("m:" + m + " n:" + n);
}
}

若直接用注释部分的代码交换i与j可以交换, 使用swap方法以后: 实际上i与j本身的值根本没有交换

值传递

swap

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//例2:
public class Test1 {
public static void main(String[] args) {
Test1 tt = new Test1();
DataSwap ds = new DataSwap();
System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);
tt.swap(ds);
System.out.println(ds);
System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);
}
//交换元素的值
public void swap(DataSwap d){
int temp = d.i;
d.i = d.j;
d.j = temp;
System.out.println(d);//打印引用变量d的值
}
}
class DataSwap{
int i = 10;
int j = 5;
}

 评论



本博客所有文章除特别声明外,均采用[(CC BY-NC-SA 4.0)]许可协议。转载请注明出处!

本站使用 Material X 作为主题 , 总访问量为 次 。
Copyright © 2019 CRainyDay's Blog 版权所有