方法重载概念+练习+方法参数的传递

1. 方法重载概述

 public static int sum(int a,int b){
             return a+b;
        }

public static int sum(int a,int b,int c){
                 return a+b+c;
            }

这里有两个方法，你会发现它们方法名是相同的，但是它们的参数列表不同，第一个是两个int 类型参数，第二个是三个int类型参数

假如把这两个方法放进同一个类中，这两个方法就构成了方法重载

public class ArraysDemo {
         public static int sum(int a,int b){
             return a+b;
         public static int sum(int a,int b,int c){
                 return a+b+c;
            } }}

方法重载指同一个类中定义多个方法之间的关系，满足下列条件的多个方法相互构成重载：

• 多个方法在同一个类中
• 多个方法具有相同的方法名
• 多个方法的参数不同，类型不同或者数量不同

2.方法重载的特点

• 重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
• 重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载

** 1. 例如：**

public class MethodDemo{
  public static void fn(int a){
           //方法体
    }
  public static int fn(int a){
          //方法体
  }
}

可以看到上面的两个方法方法名字相同，参数也相同，但是并不是方法重载，因为跟返回值相不相同无关，重点看方法名和参数

2.例二:

public class MethodDemo {
    public static float fn(int a){
           //方法体    
    }
    public static int fn(int a,int b){
           //方法体
    }
}

可以看到方法名相同，参数列表不同，这个就是方法重载

3.例三:

public static void fn(int a){
           //方法体
    }
    public static int fn(double a){
           //方法体
    }

方法名相同，方法参数不同，也是方法重载

4. 例四：

public class MethodDemo01 { //01类
    public static void fn(int a) {
        //方法体
    }
}
public class MethodDemo02 { //02类
    public static int fn(double a) {
        //方法体
    }
}

可以看到以上这个方法不是方法重载，因为分别不同的两个类,所以不是方法重载

3.范例:

public class MethodDemo {
    public static void main(String[] args) {
       //调用方法
        int result=sum(10,20);//调用两个int类型变量的方法
        System.out.println(result);

        double result2=sum(10.0,20.0);//调用两个double类型变量的方法
        System.out.println(result2);

        int result3=sum(10,20,30);//调用三个int类型变量的方法
        System.out.println(result3);
    }

    //需求1:求两个int类型数据和的方法
    public static int sum(int a,int b){
        return a+b;
    }
    //需求2:求两个double类型数据的和的方法
    public static double sum(double a,double b){
        return a+b;
    }
    //需求3:求三个int类型数据和的方法
    public static int sum(int a,int b,int c){
        return a+b+c;
    }
}

重点强调：与返回值无关。在调用的时候，Java虚拟机会通过参数的不同来区分同名的方法

4.方法重载练习

需求：使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型(byte，short，int，long)
思路：

1. 定义比较两个数字的是否相同的方法compare()方法，参数选择两个int类型参数

public static boolean compare(int a,int b){
        return a==b;
    }

2. 定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数

public static boolean compare(long a,long b){
        return a==b;
    }

3. 定义所有的重载方法，两个byte类型与两个short类型参数

public static boolean compare(byte a,byte b){
        return a==b;
    }
    public static boolean compare(short a,short b){
        return a==b;
    }

4. 完成方法的调用，测试运行结果

public static void main(String[] args) {
        System.out.println(compare(10,20));
    }

完整代码：

public class MethodDemo {
    public static void main(String[] args) {
        //调用方法
        System.out.println(compare(10,20));
    }
    public static boolean compare(int a,int b){
        System.out.println("int");//给每个类型方法打备注，看运行后的结果是调用的哪一个
        return a==b;
    }
    public static boolean compare(long a,long b){
        System.out.println("long");//给每个类型方法打备注，看运行后的结果是调用的哪一个
        return a==b;
    }
    public static boolean compare(byte a,byte b){
        System.out.println("byte");//给每个类型方法打备注，看运行后的结果是调用的哪一个
        return a==b;
    }
    public static boolean compare(short a,short b){
        System.out.println("short");//给每个类型方法打备注，看运行后的结果是调用的哪一个
        return a==b;
    }
}

可以看出来结果走的是int，因为整数默认类型为int，如果想调用其他类型的方法就使用强制转换System.out.println(compare((byte)10,(byte)20));
如果是long类型后面加个LSystem.out.println(compare(10L,20L));

5.方法参数传递(基本类型)

对于基本数据类型的参数，形式参数的改变不影响实际参数的值

public static void main(String[] args){
        int number=100; //实际参数
        System.out.println("调用change方法前:"+number);
        change(number);  //调用change方法
        System.out.println("调用change方法后:"+number);
    }
    public static void change(int number){//int number 形式参数
        number =200;//给形参赋值
      }

输出结果为：

调用change方法前:100 调用change方法后:100

6.方法参数传递(引用类型)

对于引用类型的参数，形式参数的改变，影响实际参数的值

 public static void main(String[] args){
        int[] arr={10,20,30}; //实际参数
        System.out.println("调用change方法前:"+arr[1]);
        change(arr);  //调用change方法
        System.out.println("调用change方法后:"+arr[1]);
    }
    public static void change(int[] arr){//int[] arr 形式参数
        arr[1] =200;//给形参赋值
    }

输出结果为：

调用change方法前:20 调用change方法后:200

理想的咸鱼猿©个人笔记

最后

以上就是满意小馒头为你收集整理的方法重载概念+练习+方法参数的传递的全部内容，希望文章能够帮你解决方法重载概念+练习+方法参数的传递所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。