How do I know what class called the abstract method?

Question

say there are 2 classes...

public class NotAbstract1 extends AnAbstract {
  NotAbstract1() { super(); }
}

public class NotAbstract2 extends AnAbstract {
  NotAbstract2() { super(); }
}

public abstract class AnAbstract {
  AnAbstract() { //do something }
  abstract void saySomething() { System.out.println("Something"); }
}

In this example, NotAbstract1 and NotAbstract2 can call saySomething(). How can I, from within the saySomething() method of AnAbstract, recognize the class which called it? Without passing in the class or an identifier.

Again, the easy solution is to change the method signature to be saySomething(Class clazz) but I'd like to not do that. I have a feeling it can be done with reflection so I'm adding that tag to the question.

Answer 1

You can call this.getClass() at saySomething() - it will return you the type of the current instance - either notAbstract1 or notAbstract2.

Answer 2

First of all, this line will not compile:

abstract void saySomething() { System.out.println("Something"); }

You cannot both use abstract modifier and provide a method body.

For printing the caller's class, you can write:

void saySomething() {
    System.out.println(this.getClass().toString());
}

Answer 3

The abstract keyword in

abstract void saySomething();

is a place holder. There cannot be code associated with it. What it does is ensure that

public class NotAbstract1
public class NotAbstract2

both have a real implementations like so

public class NotAbstract1 extends AnAbstract {
   void saySomething() {
     System.out.println("I'm NotAbstract1");
   }
}

public class NotAbstract2 extends AnAbstract {
   void saySomething() {
     System.out.println("I'm NotAbstract2");
   }
}

The compiler does these verifications that the saySomething() method exists in the sub classes when you compile NotAbstract1 and NotAbstract2.

When you are holding a

AnAbstract object = .... get it from somewhere ...

You will be holding either a NotAbstract1 a NotAbstract2 or some other subclass of AnAbstract, but you will be holding as anAnAbstract type.

When you call

AnAbstract object = .... get it from somewhere ...
object.saySomething();

If the object was originally constructed as a NotAbstract1 you would run

System.out.println("I'm NotAbstract1");

If the object was originally constructed as a NotAbstract2 you would run

System.out.println("I'm NotAbstract2");  

If the object was some other kind of AnAbstract you would run whatever was in that sub-class's definition of saySomething().

Answer 4

Although you can check using this.getClass() inside saySomething(), but if you want to have different behaviour of this method based upon which class it is called from you should be ideally overriding saySomething() method in those classes.