在Java调用哪个重载方法

Question

我在超类中有一个重载方法的基本继承情况。

public class Person {
    private String name;
    private int dob;
    private String gender;

    public Person(String theName, int birth, String sex){
        name = theName;
        dob = birth;
        gender = sex;
    }

    public void work(){
        getWorkDetail(this);
    }

    public void getWorkDetail(Employee e){
        System.out.println("This person is an Employee");
    }

    public void getWorkDetail(Person p){
        System.out.println("This person is not an Employee");
    }
}

下面的Employee类扩展了上面的Person类：

public class Employee extends Person {

    String department;
    double salary;

    public Employee(String theName, int birth, String sex){
        super(theName, birth, sex);
        department = "Not assigned";
        salary = 30000;
    }
}

main方法只是创建一个Employee对象（静态和动态类型）并调用。工作（）：

public static void main(String[] args){
    Employee e1 = new Employee("Manager1", 1976, "Female");
    e1.work();
}

最后打印出来

此人不是员工

看了这个，我想既然对象的静态和动态类型都是e1，它会调用Person中的重载方法，该方法将雇员作为参数。由于我显然错了，我打开了一个调试器，假设Person类中的getWorkDetail（this）行中对“this”的引用一定已经变成了它的超级类。然而，这不是我发现的。

显然，在代码中的这一点上，这个是一个雇员对象，但是它仍然选择执行重载的方法getWorkDetail（Person p）。有人能解释这种行为吗？

Answer 1

在某些语言中，参数被解析为其动态类型，但在java中则不是。编译器已经在编译时确定您的getWorkDetail（这个）的位置 将被删除这个属于Person类型，因此调用getWorkDetail（Person e）。在你的具体案例中，解决方案是显而易见的。正如其他人已经指出的，您需要重写Employee类中的getWorkDetail（）。

要解决在运行时解析参数类型的一般问题，应避免使用instanceof运算符，因为这通常会导致代码不干净。

如果您有两个不同的类，那么像上面所说的那样简单的解决方案就不可能了。在这种情况下，您必须使用访客模式。

考虑以下类：

public interface Animal {
    default void eat(Food food) {
        food.eatenBy(this);
    }

    void eatMeat(Meat meat);

    void eatVegetables(Vegetables vegetables);
}

public class Shark implements Animal {
    public void eatMeat (Meat food) {
        System.out.println("Tasty meat!");
    }

    public void eatVegetables (Vegetables food) {
        System.out.println("Yuck!");
    }
}

public interface Food {
    void eatenBy(Animal animal);
}

public class Meat implements Food {
    public void eatenBy(Animal animal) {
        animal.eatMeat(this);
    }
}

public class Vegetables implements Food {
    public void eatenBy(Animal animal) {
        animal.eatVegetables(this);
    }
}

你可以这样称呼它：

Animal animal = new Shark();
Food someMeat = new Meat();
Food someVegetables= new Vegetables();
animal.eat(someMeat);        // prints "Tasty meat!"
animal.eat(someVegetables);  // prints "Yuck!"

按照访客模式调用动物。吃将调用食物。eatenBy，它由肉和蔬菜实现。这些类将调用更具体的eatMeat或EatGreens方法，该方法使用正确的（动态）类型。

Answer 2

重载解析发生在编译时，而不是运行时。

因此，当您调用getWork细节（this）时，this被假定为Person（这是静态类型），因此称为相应的重载。

注意：在Employee类中使用this将使其成为Employee类型。您可以通过如下方式在Employee中重载work（）来验证这一点。

class Employee extends Person {
    ...

    public void work() {
        getWorkDetails(this); // This should print "This person is an Employee"
    }
}

Answer 3

与方法重写不同，方法重载是基于静态类型链接的。在这种情况下，Person中的getWorkDetail（this）只知道Person类型。

方法重载不是为了提供动态运行时行为而设计的。

要利用动态绑定，您可能需要重新设计代码以覆盖这些方法，而不是：

public static void main(String[] args) throws IOException {
    new Employee("Manager1", 1976, "Female").getWorkDetail();
    new Person("Manager1", 1976, "Female").getWorkDetail();
}

并基于实现类修改行为。当然，您可以重载方法，只要您在必要时也注意重写重载的方法。

class Person {
    private String name;
    private int dob;
    private String gender;

    public Person(String theName, int birth, String sex) {
        name = theName;
        dob = birth;
        gender = sex;
    }

    public void getWorkDetail() {
        System.out.println("This person is not an Employee");
    }
}

class Employee extends Person {

    String department;
    double salary;

    public Employee(String theName, int birth, String sex) {
        super(theName, birth, sex);
        department = "Not assigned";
        salary = 30000;
    }

    public void getWorkDetail() {
        System.out.println("This person is an Employee");
    }
}