How can I prevent invoking a static method on an instance of my class?

Question

I have the following class, which is used for controlling some debugging and beta testing options in various places in my Android app. It just contains some flags and some logic to (de)serialize it to/from JSON.

public class DevConfiguration {
    public boolean dontSendSMS;


    public static String toJsonString(DevConfiguration devConfiguration) {
        JSONObject json = new JSONObject();

        if( devConfiguration != null ) {
            try {
                json.put("dontSendSMS", devConfiguration.dontSendSMS);
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }

        return json.toString();
    }


    public static DevConfiguration fromJsonString(String jsonString) {
        if( jsonString.isEmpty() )
            return null;

        DevConfiguration result = new DevConfiguration();

        try {
            JSONObject jsonObj = new JSONObject(jsonString);
            result.dontSendSMS = jsonObj.optBoolean("dontSendSMS", false);
        } catch (JSONException e) {
            e.printStackTrace();
        }

        return result;
    }

}

Now, in one of my services I receive a serialized DevConfiguration object in an Intent, and might later pass it on to another service:

serviceIntent.putExtra("dev_conf", DevConfiguration.toJsonString(mDevConfiguration));

I choose to make the toJsonString() method static, so that I don't risk invoking it on a null instance. However, it's still possible to make a mistake somewhere and invoking the static method on an instance - potentially a null instance!

mDevConfiguration.toJsonString(mDevConfiguration);

There is a Lint warning in Android Studio, but still it's a potential NullPointerException bug waiting to happen. I thought it might be possible to hide it by defining a similar private method but with a different signature

/** Hide instance implementation **/
private String toJsonString(Object o){ return ""; }

but of course calling it with a DevConfiguration parameter will invoke the static method anyway, and the IDE doesn't give any more warnings than before either.

Is there any way to "hide" the static method from instance variables?

EDIT

Comments make it clear that invoking a static method on a null instance is perfectly legal. However, the question is not "How do I prevent a NullPointerException when invoking a static method on a null instance?", but the more general "How can I prevent invoking a static method on an instance of my class?".

In other words - is there any way to prevent the compiler from compiling if one accidentally tries to invoke a static method on an instance?

Answer 1

Calling a static method on a variable with null value will not raise NullPointerException. Following code will print 42 even though variable i is null.

public class Test {
    public static void main(String... args) {
        Integer i = null;
        System.out.println(i.parseInt("42"));
    }
}

When calling static methods by variable, what really matters is the declared type of the variable and not the referenced type of its value. This is related to the fact that static methods in java are not polymorphic.

---

„How can I prevent invoking a static method on an instance of my class?"

Calling static methods by variable is just a regular language feature defined in the Java spec. I’d be surprised if there were any method to suppress it in general.

If I had to do it for a selected class, I would probably migrate static methods to a separate „companion” utility (as described in another answer).

But having such static (factory) methods in your class is a perfectly fine idiom (see for example: Joshua Bloch, „Effective Java”, Item 1: Consider static factory methods instead of constructors). I wouldn’t easily give up on it.

Answer 2

I see a few ways you could do this:

1. Use a Utils class:

   public class Utils {
       public static String toJsonString(DevConfiguration devConfiguration) {
           JSONObject json = new JSONObject();
   
           if( devConfiguration != null ) {
               try {
                   json.put("dontSendSMS", devConfiguration.dontSendSMS);
               } catch (JSONException e) {
                   e.printStackTrace();
               }
           }
   
           return json.toString();
       }
   
   
       public static DevConfiguration fromJsonString(String jsonString) {
           if( jsonString.isEmpty() )
               return null;
   
           DevConfiguration result = new DevConfiguration();
   
           try {
               JSONObject jsonObj = new JSONObject(jsonString);
               result.dontSendSMS = jsonObj.optBoolean("dontSendSMS", false);
           } catch (JSONException e) {
               e.printStackTrace();
           }
   
           return result;
       }
   }
   

   Now you can just makes calls to Utils.method() and avoid confusion.

2. Use Kotlin

   Kotlin actually makes it really hard (if not impossible) to call a static method on a dynamic receiver. It won't show in the method suggestions, and will underline in red if you type it manually. It might not even compile, although I haven't gotten that far.

   Kotlin also has built-in null protection: instance?.method(). The ? means method() just won't execute if instance is null.

3. Just don't call a static method on a dynamic receiver. If you do it by accident, go back and fix it. You shouldn't be relying on Java to work around your syntax errors for you.

Finally, why even do this? I highly doubt mDevConfiguration is ever null, unless you initialize it in a really weird spot. If it is, you may want to look at reorganizing your code. Because, again, you shouldn't be relying on Java to work around your syntax errors for you. Also, if it is null, it won't throw an NPE, at least in Java, since it doesn't need a dynamic receiver to run (this is probably different in Kotlin).

It's up to you to make code that works as it should, and implement the proper null checks, error handling, etc. If you miss something, it's no big deal; that's why you test your code and fix the crashes and bugs you catch before you release it. Anything you don't catch will be reported by the Google Play Console (if you publish there) or Firebase (if you implement that) or your users.

Sorry if the above sounds harsh, but I'm really having trouble seeing why you'd want to do this instead of just checking your code.

If you really want to keep this structure, at least make the constructor for DevConfiguration private:

public class DevConfiguration {
    //...

    private DevConfiguration() {}

    //...
}

That way, only the static methods inside it can create an instance.