方法重载

Posted 2020-12-15 wx1995

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。调用重载方法时，Java编译器能通过检查调用的方法的参数类型和个数选择一个恰当的方法。

 

在java语言中，是怎么进行方法区分的呢？
 首先java编译器会通过方法名进行区分，但是Java语言允许方法名相同的情况出现，如果方法名相同的情况下，编译器会通过方法的形式参数列表进行方法的区分。

 

什么时候考虑使用方法重载？

在同一个类中，如果“功能1”和“功能2”它们的功能是相似的，那么可以考虑将他们的方法名一致，这样代码既美观，又便于后面的维护

 

什么时候代码会发生方法重载？
 条件1：在同一个类当中
 条件2：方法名相同
 条件3：参数列表不同
     参数的个数不同算不同
     参数的类型不同算不同
     参数的顺序不同算不同
 只要同时满足以上三个条件，就可以认定方法和方法之间发生了重载机制

注意：不管代码怎么写，最终一定能让java编译器很好的区分开这两个方法--看方法名和参数列表，就是你调用的时候方法名一样表达式不一样就是重载

 

//以下代码没有使用重载
public class OverloadTest01{
    public static void main(String[] args){
        int i=sumInt(10,20);
        System.out.println(i);
        
        long l=sumLong(10,20);
        System.out.println(l);
        
        double d=sumLong(10,20);
        System.out.println(d);
    }
    public static int sumInt(int a,int b){
        return a+b;
    }
    public static long sumLong(long a,long b){
        return a+b;
    }
    public static double sumDouble(double a,double b){
        return a+b;
    }
}


//使用方法重载机制
public class OverloadTest02{
    public static void main(String[] args){
        System.out.println(sum(10,20));
        System.out.println(sum(10L,20L));
        System.out.println(sum(10.0,20.0));
    }
    public static int sum(int a,int b){
        System.out.println("int类型求和");
        return a+b;
    }
    public static long sum(long a,long b){
        System.out.println("long类型求和");
        return a+b;
    }
    public static double sum(double a,double b){
        System.out.println("double类型求和");
        return a+b;
    }
}

 

public class OverloadTest03{
    public static void main(String[] args){
        m1();
        m1(100);
        
        m2(10,3.14);
        m2(3.14,10);
        
        m3(100);
        m3(3.17);
    }
    //m1方法是参数个数不同
    public static void m1(){
        System.out.println("m1无参数的执行！");
    }
    public static void m1(int a){
        System.out.println("m1有一个int参数执行！");
    }
    
    //m2方法是参数的顺序不同
    public static void m2(int x,double y){
        System.out.println("m2(int x,double y)");
    }
    public static void m2(double y,int x){
        System.out.println("m2(double y,int x)");
    }
    
    //m3方法是参数的类型不同
    public static void m3(int x){
        System.out.println("m3(int x)");
    }
    public static void m3(double x){
        System.out.println("m3(double x)");
    }
    
    //m4方法重复了，编译会报错
    public static void m4(int x,int y){
        System.out.println("m4(int x)");
    }
    public static void m4(int a,int b){
        System.out.println("m4(int a)");
    }
    
    //m5方法虽然返回值类型不同，但是在方法调用的时候，返回值可以接收也可以不接收
    //如 就调用时就写 m5(),这时编译会报错，无法区分这两个方法
    //所以方法重载与返回值类型无关
    public static int m5(){
        return;
    }
    public static double m5(){
        return 1.0;
    }
    
    //m6 方法重复了，重载与修饰符列表无关
    void m6(){
        
    }
    public static void m6(){
        
    }
}

方法重载使用总结：同一个类中，方法名相同，形式参数类表不同，和返回值类型，修饰符列表无关