[SalesForce] Static method able to be called/executed from class instantiated from type.newInstance() with interface. Expected

When trying to execute a static method from an instance of a class

testMe tmp = New testMe();
tmp.myStaticMethod('a','b');

we get the familiar:

Static method cannot be referenced from a non static context: void myStaticMethod(Id, String)

However if the class implements an interface, instantiating a new instance of that that interface allows us to execute the static method passing in the parameters

Is this expected / documented?

global interface testIt{
    void myStaticMethod(String a, String b);
}

global class testMe implements testIt{

    global static void myStaticMethod(String a, String b){
        system.debug(a + ' - ' + b);
    }

}

The following executes just fine

System.Type apiMethod = Type.forName('ns', 'testMe');
testit tmp = (testit)apiMethod.newInstance();
tmp.myStaticMethod('a','b');

17:03:46.25 (12026653450)|USER_DEBUG|[171]|DEBUG|a – b

I was expecting that the static instance would not be able to be called but it allows me to. If this is expected great, I will go ahead and use it but if it is not expected I would prefer not to package something I cannot reverse….

I suspect it has to do with the interface since the interface method is not static rather the implementation of it is static in the class. To test the theory I tried this and it executed just fine without complaining about the static method

testIt tmp = (testIt)(New testMe());
tmp.myStaticMethod('a','b');

All answers appreciated but especially thankful if there is some documentation that can be pointed to

Best Answer

You shouldn't depend on the behavior. The documentation states:

A class static variable can’t be accessed through an instance of that class. If class MyClass has a static variable myStaticVariable, and myClassInstance is an instance of MyClass, myClassInstance.myStaticVariable is not a legal expression.

You should always declare methods as instance methods, just to be safe.

Related Solutions

[SalesForce] Static method cannot be referenced from a non static context: List

The code you have posted does compile. To call it you will need to use the class name like this (because the method is static):

String[] stringArray = test_clonestring.generateStringArray(5);

This will not compile:

String[] stringArray = new test_clonestring().generateStringArray(5);

[SalesForce] How to deserialize into interface type when concrete type is unknown

I think you should revisit the idea of using an abstract class rather than an interface. You can use the former to enforce a contract.

public class Demo
{
    final String typeName;
    public String getSomeProperty() { return typeName; }
    public abstract List<User> doStuff();
}

Granted, this definition cannot be constructed either, but deserialization into this type is allowed.

Demo instance = (Demo)JSON.deserialize('{}', Demo.class);
system.debug(instance.getSomeProperty());

And the contract gets enforced, for if you try to save a class which doesn't implement the method:

class Foo extends Demo { }

You get a compile-time error:

Class Foo must implement the abstract method: List<User> Demo.doStuff()

As a benefit, properties like typeName can be preserved throughout the serialization round-trip.

Here's a simple demonstration of that process. First define this extension:

public class Foo extends Demo
{
    final String profileName;
    public override List<User> doStuff()
    {
        return [
            SELECT Username FROM User
            WHERE Profile.Name = :profileName
        ];
    }
}

Now run this script:

String payload = '{"typeName": "Foo", "profileName": "System Administrator"}';
Map<String, Object> controllerData = (Map<String, Object>)JSON.deserializeUntyped(payload);
String controllerType = (String)controllerData.get('typeName');

Demo controller;
if (controllerType != null)
{
    controller = (Demo)JSON.deserialize(payload, Type.forName(controllerType));
    system.debug(controller.doStuff());
}

As far as why your repo works in aura but not in a pure Apex context, it looks like the system acts similarly to Visualforce, treating methods prefixed with get as properties and adding them to the serialization (since the end result is indecipherable from { get; set; } notation). If you had named your method retrieveName instead of getName, I suspect it would not have worked in aura either. You can hack around it with mimicry along the lines of:

public class MyClass
{
    final String name = getName();
    public String getName() { return 'MyClass'; }
}

But I suspect that's not a tenable long-term solution.

Best Answer

Related Solutions

[SalesForce] Static method cannot be referenced from a non static context: List

[SalesForce] How to deserialize into interface type when concrete type is unknown

Related Topic