Unlike method overrides, method overloads are linked based on the static type. And in this case, getWorkDetail(this) in Person only knows about the Person type.

Method overloading is not designed to provide dynamic runtime behavior.

To take advantage of dynamic binding, you may need to redesign your code to override the methods, instead:

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

And modify behavior based on implementing classes. Of course, you can overload methods, as long as you take care of overriding the overloaded methods too, if required.

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");    }}

The overload resolution happens during compile time, not at runtime.

So, when you call getWorkDetails(this), this is assumed to be a Person (which is the static type) and hence called the corresponding overload.

Note: Using this inside Employee class would have made it an Employee type. You can verify this by overloading work() in Employee like this.

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

Problem specific solution

In some languages parameters are resolved to their dynamic type, but not in java. The compiler already determines at compile time where your getWorkDetail(this); will go. this is of type Person, so getWorkDetail(Person e) is called. In your specific case the solution is quite obvious. As others have already pointed out, you'll need to override getWorkDetail() in the Employee class.

Resolving methods to their dynamic parameter types

To solve the general problem of resolving parameter types at runtime, using the instanceof operator should be avoided, as it usually leads to unclean code.

If you have two different classes, a solution as simple as stated above is no longer possible. In these cases you'll have to use the visitor pattern.

Consider the following classes:

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);    }}

Which you can call like this:

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

Following the visitor pattern calling Animal.eat will call Food.eatenBy, which is implemented by both Meat and Vegetables. Those classes will call the more specific eatMeat or eatVegetables method, which uses the correct (dynamic) types.