面向对象1.2

crainyday

Java / JavaSE

发布于：2019年3月19日

字数：1k字

时长：4分钟

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

一.overload(重载)

1.重载要求:

同一个类中

方法名必须相同

方法的参数列表不同(①参数的个数不同②参数类型不同)
注意: 方法的重载与方法的返回值类型没有关系!

//如下的四个方法构成重载
//定义两个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.在一个方法中, 最多声明一个可变个数的形参

One More Thing 👇

//如下四个方法构成重载
//在类中一旦定义了重载的可变个数的形参的方法以后, 下面的前两个方法可以省略
    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.方法的参数传递

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

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

//例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本身的值根本没有交换

//例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;
}