重载的原理java

原文链接
这篇文章讲的很好。
总结一下这篇文章：
重载是在编译期间就决定的，每个类的方法都有唯一的方法签名，不能存在两个方法签名一样的，方法签名由方法名称和参数列表决定。
重载。

public class Main {
	// 声明一个父类
    static class Human {
    }
    // 声明两个子类
    static class Man extends Human {
    }
    static class Woman extends Human {
    }

    // 三个重载方法，参数类型分别为以上三种类型
    static void sayHello(Human human){
        System.out.println("human say Hello");
    }
    static void sayHello(Man man){
        System.out.println("man say Hello");
    }
    static void sayHello(Woman woman){
        System.out.println("woman say Hello");
    }

    public static void main(String[] args) {
        Human man = new Man();
        Human woman = new Woman();
        sayHello(man);
        sayHello(woman);
    }
}

输出结果：

human say Hello
human say Hello

根据结果可以看到，最终都调用了参数为父类型Man的sayHello方法。这是为什么呢？这是因为对重载方法的选择，是根据变量的静态类型来确定的，而不是实际类型。比如代码Human man = new Man()，Human就是变量man的静态类型，而Man是它的实际类型。我们都知道，在多态的情况下调用方法，会根据实际类型调用实际对象的方法，但是在重载中，是根据静态类型来确定调用哪一个方法的。在上面的代码中，man和woman对象的静态类型都是Human，所以都调用static void sayHello(Human human)方法。和调用重写方法不同，由于一个对象的静态类型在编译期间就可以确定，所以调用哪个重载方法是在编译期就确定好了，这叫静态分派，而调用重写的方法却要在运行时才能确定具体类型，这叫动态分派。
 接下来，我们再来看一个更加复杂的情况，如下代码：

public class Test {

    static void sayHello(char arg) {
        System.out.println("hello, char");
    }

    static void sayHello(int arg) {
        System.out.println("hello, int");
    }

    static void sayHello(long arg) {
        System.out.println("hello, long");
    }

    static void sayHello(Character arg) {
        System.out.println("hello, Character");
    }

    static void sayHello(Serializable org) {
        System.out.println("hello, Serializable");
    }

    static void sayHello(Object arg) {
        System.out.println("hello, object");
    }

    static void sayHello(char... org) {
        System.out.println("hello, char...");
    }

    public static void main(String[] args) {
        sayHello('a');
    }
}

重载调用顺序：
char->int->long->float->double>类型转换>有参列表
类型转换如果有两个类型同等级的就会报错。