方法重载Overload

方法重载是java/c++里面的一个特性，目的是为了可以在参数不同的情况下，访问同一个方法名的方法，前期主要用于类的构造器，因为类本身有一个默认的构造器(无参构造器)，但如果不想以默认的构造器进行实例化对象，有想要创建对象，再根据构造器的定义，方法名与类型相同，所以由此引申出方法重载(Overload)

1 区分方法重载的方法

方法重载(Overload)最明显的区分方法就是 方法名相同 参数列表不同 包括<font color="red">参数列表的顺序</font>。方法重载与返回值无关

因为有时候 执行方法的目的 并不在与返回值 而在于方法的副作用。

例如

public String loadTest(String s, int i){
    return "";
}
public String loadTest(int i, String s){
    return "";
}
//以上两个方法也是方法重载，但如果只是调整参数顺序的话，那重载也没啥意义了。

2 涉及基本类型的方法重载

基本类型在方法中可以从一个"较小"的类型自动提升到一个"较大"的类型，如下:

public class TestOverload {

    void f1(char i){
        System.out.print("f1(char)");
    }
    void f1(byte i){
        System.out.print("f1(byte)");
    }
    void f1(short i){
        System.out.print("f1(short)");
    }
    void f1(int i){
        System.out.print("f1(int)");
    }
    void f1(long i){
        System.out.print("f1(long)");
    }
    void f1(float i){
        System.out.print("f1(float)");
    }
    void f1(double i){
        System.out.print("f1(double)");
    }

    /*f2*/
    void f2(byte i){
        System.out.print("f2(byte)");
    }
    void f2(short i){
        System.out.print("f2(short)");
    }
    void f2(int i){
        System.out.print("f2(int)");
    }
    void f2(long i){
        System.out.print("f2(long)");
    }
    void f2(float i){
        System.out.print("f2(float)");
    }
    void f2(double i){
        System.out.print("f2(double)");
    }

    /*f3*/
    void f3(short i){
        System.out.print("f3(short)");
    }
    void f3(int i){
        System.out.print("f3(int)");
    }
    void f3(long i){
        System.out.print("f3(long)");
    }
    void f3(float i){
        System.out.print("f3(float)");
    }
    void f3(double i){
        System.out.print("f3(double)");
    }

    /*f4*/
    void f4(int i){
        System.out.print("f4(int)");
    }
    void f4(long i){
        System.out.print("f4(long)");
    }
    void f4(float i){
        System.out.print("f4(float)");
    }
    void f4(double i){
        System.out.print("f4(double)");
    }

    /*f5*/
    void f5(long i){
        System.out.print("f5(long)");
    }
    void f5(float i){
        System.out.print("f5(float)");
    }
    void f5(double i){
        System.out.print("f5(double)");
    }

    /*f6*/
    void f6(float i){
        System.out.print("f6(float)");
    }
    void f6(double i){
        System.out.print("f6(double)");
    }

    void f7(double i){
        System.out.print("f7(double)");
    }

    void testConstVal(){
        System.out.print("常量 5 : ");
        f1(5); f2(5); f3(5); f4(5); f5(5); f6(5); f7(5);
    }

    void testChar(){
        System.out.print("char : ");
        char x = 'x';
        f1(x); f2(x); f3(x); f4(x); f5(x); f6(x); f7(x);
    }
    void testInt(){
        System.out.print("int : ");
        int x = 3;
        f1(x); f2(x); f3(x); f4(x); f5(x); f6(x); f7(x);
    }

    void testShort(){
        System.out.print("short : ");
        short x = 3;
        f1(x); f2(x); f3(x); f4(x); f5(x); f6(x); f7(x);
    }

    void testLong(){
        System.out.print("long : ");
        long x = 3;
        f1(x); f2(x); f3(x); f4(x); f5(x); f6(x); f7(x);
    }

    void testFloat(){
        System.out.print("float : ");
        float x = 3;
        f1(x); f2(x); f3(x); f4(x); f5(x); f6(x); f7(x);
    }
    void testDouble(){
        System.out.print("double : ");
        double x = 3;
        f1(x); f2(x); f3(x); f4(x); f5(x); f6(x); f7(x);
    }

    public static void main(String[] args) {

        System.out.println("****开始测试***");
        TestOverload t = new TestOverload();
        t.testConstVal();
        System.out.println();
        t.testChar();
        System.out.println();
        t.testInt();
        System.out.println();
        t.testShort();
        System.out.println();
        t.testLong();
        System.out.println();
        t.testFloat();
        System.out.println();
        t.testDouble();
    }
}

//结果如下:
****开始测试***
常量 5 : f1(int)f2(int)f3(int)f4(int)f5(long)f6(float)f7(double)
char : f1(char)f2(int)f3(int)f4(int)f5(long)f6(float)f7(double)
int : f1(int)f2(int)f3(int)f4(int)f5(long)f6(float)f7(double)
short : f1(short)f2(short)f3(short)f4(int)f5(long)f6(float)f7(double)
long : f1(long)f2(long)f3(long)f4(long)f5(long)f6(float)f7(double)
float : f1(float)f2(float)f3(float)f4(float)f5(float)f6(float)f7(double)
double : f1(double)f2(double)f3(double)f4(double)f5(double)f6(double)f7(double)
Process finished with exit code 0

如上：如果基本类型参数在重载方法形参里面没有 会自动提升匹配形参里面有的重载方法。

如果传入的实际参数大于重载方法申明中的形式参数，一般编辑不会通过的，参数必须经过强转。

换句话说：

对于基本类型而言：小转大 可以转 例如 short 类型自动转化成 int 类型

​ 大转小 必须强转 否则编译不会通过 而且还会出现精度丢失的情况 例如 double -> float