OOP concepts, if used at all in this example, are only trivially used. So my answer to this question would be none, there are no OOP concepts demonstrated here.

You could argue that the existence of the Greeting class itself "demonstrates" an OOP concept, but only trivially so since it encapsulates no state and has no behaviors defined at the instance level (other than those inherited by Object). Similarly, you could argue that Greeting inherits from Object, but it's not really a "demonstration" of inheritance or polymorphism because it's a bit of a stretch to say that any caller could ever meaningfully leverage either of those concepts with the Greeting class.

Let's contrive an example where Greeting could be used polymorphically, for example, just to make the point. Since it only has a static main method, the only polymorphic uses of it would be if some other class was responsible for managing a bunch of random objects. Perhaps it is using these objects as thread locks, so it doesn't matter what type the object is so long as multiple threads all use the same one.

But since this isn't specific to Greeting, that means this particular class isn't a very good demonstration of that polymorphism. It's a demonstration of synchronizing on an object, which is not an OOP concept, but doesn't leverage polymorphism in any way.

So how can we change this example? We could say that a class is collecting main classes. We're writing some kind of startup manager that can invoke a main method so users can indirectly invoke a main method through this one class that might bring some benefits or extra capabilities, and to do its job, it needs to collect a bunch of classes that define a main method for some reason? In that case, since main(…) is a static method, the only thing this startup class could do is collect a bunch of main classes as Objects. This would be a trivial example of polymorphism, but it's still not that good because we might want to collect an instance of a main class, but the author of that main class adds a private constructor to prevent it from being instantiated. In that case, it's still a valid main class, but the idea of collecting instances won't work for this example, so we'd have to change our design to collect the Class objects of the main classes instead.

When it's even difficult to contrive any example of how this could be a demonstration of an OOP concept, I'd say it doesn't really demonstrate any of them. However, talking through why would probably score you some points in an interview setting.