Thread: Why is there no "package-private interfaces" and "abstract static"?

These are very theoretic questions, I know, but nevertheless I am curious as to why this is not possible; what is the reasoning behind this?

Question 1).
Why must interfaces be public? Why can I not make them package-private (and their methods too)?
I would like to use interfaces to structure the internal code of an engine, but many of these methods must NOT be called from outside of the engine as they may easily result in undefined behaviour if called at a bad time. But unfortunately I am forced to make them public since they are part of an interface. I am very disappointed by this.

Question 2).
Why is it not possible to declare "abstract static" methods? I know that this would be against the OOP paradigm, but so are static methods alone. It would really be nice sometimes to be able to do this.

Thanks for your answers.

Hello.
Did you do the experiment once before posting the first question?
If not can you do one experiment before reading further.
If you cannot then try this experiment and tell me if it is valid or not.

  public class Run  {
    private interface I1  {}
    protected interface I3 {}
    public static void main(String str[])  {
      System.out.println("private, package, protected and public interfaces are all valid in Java");
    }
  }
  interface I2  {}

Coming to the second question, an abstract method is one that does not contain body. A static method is one that can be invoked irrespective of whether an instance of the class to which it belongs to is created or not. Hence these two modifiers "static" and "abstract" cannot appear together because each one violates the property of the other.

Thanks,
Syed.

I think that came out wrong; of course I know that an interface can be declared private; but all of its methods are still public.
Here is an example of what I mean:


I have an Engine, and an important EngineClass which is part of the Engine.
I have several kinds of EngineParts and they are all supposed to implement the interface PrivateInterface which provides the key functionality of the Engine.
However, some functions, like the doStuff() function, are not supposed to be visible to the user outside. This is not possible in java.

This is what is possible in java:

package enginepkg;
 
public class Engine {
 
	private static interface PrivateInterface {
		public void doStuff();
	}
 
	public static class EngineClass implements PrivateInterface {
		public void doStuff() {
 
		}
	}
 
}

package userpkg;
 
import enginepkg.Engine.EngineClass;
 
public class OutsideClass {
 
	public void test() {
		EngineClass ec = new EngineClass();
		ec.doStuff();
	}
 
}

This is what I would like to have:

package enginepkg;
 
public class Engine {
 
	private static interface PrivateInterface {
		void doStuff();
	}
 
	public static class EngineClass implements PrivateInterface {
		void doStuff() {
 
		}
	}
 
}

package userpkg;
 
import enginepkg.Engine.EngineClass;
 
public class OutsideClass {
 
	public void test() {
		EngineClass ec = new EngineClass();
		//ec.doStuff(); <- This method can not be called by a class from outside the package "enginepkg".
	}
 
}

Coming to the second question, an abstract method is one that does not contain body. A static method is one that can be invoked irrespective of whether an instance of the class to which it belongs to is created or not. Hence these two modifiers "static" and "abstract" cannot appear together because each one violates the property of the other.

I dont see how one violates the property of the other.
An abstract static method would be a method which can only be invoked on the subclasses of an abstract class; and each of these subclasses has to define the static method in question.

Hello.
Let me first clarify the second question.
You said static and abstract do not violate the each others properties. Yes it does. Let me quote your statement,
"An abstract static method would be a method which can only be invoked on the subclasses of an abstract class; and each of these subclasses has to define the static method in question".
When a method is static it can be invoked with or without instantiating the class to which it belongs to. There is a possibility that someone will invoke that method without creating an object of that class. But if the method is abstract what will JVM do?

Coming to the first question, an interface must contain public methods only. Even if we do not mention the access specifier by default it will become public. Actually the real power of interfaces will be known if we develop real enterprise applications. There could be good reasons why methods in interfaces are forced to be public. I do not know them as of now. May be someone else will give. If I find them out I shall share with you.

Syed.

--- Update ---

Cornix,
Also, in your first post you said "Why must interfaces be public? Why can I not make them package-private (and their methods too)?".
After my reply then in your second post you said "of course I know that an interface can be declared private".
You contradicted yourself.

Syed.

1). The compiler can check if you are trying to call an abstract method or not. In the same way the compiler could check if you are calling an abstract static method and if you try it will not compile. Thats nothing impossible and I still can not see why you think this would not work in any way.

2). I know what interfaces can do and what they cant do. I want to know why this artificial limit is imposed on us as it doesnt seem to have any purpose in my opinion. I can not see any good reason why a package-private interface method should be impossible.

Hello.
I think you should discuss these two matters with James Gosling.
Let me know once you have answers from him.

Thanks,
Syed.

abstract static is dis-allowed because of the way static methods are implemented they cannot support the necessary implementation details that instances have to support inheritance and method overriding.

But why is that? The good thing about programming is that you can change things later on without any material loss, the designers of java could just change the way static methods work and allow abstract static method declarations. I would like to hear a good argument as to why this doesnt work.

It does seem like not allowing protected methods in interfaces is a bit of an oversight, though. The best solution in Java is to design your class hierarchy such that you can extend some key common classes which do allow protected abstract methods. This is part of the trade-off between multiple inheritance and single inheritance+interfaces (more power vs. more safety).

The problem is if you already extend a different, equally important class. It seems to me as if inheritance is completely useless in java if you program on a higher level. I just want to have a clean and simple program structure but the way java forces single-inheritance and interfaces to only have public methods makes this very hard sometimes.
The best way to achieve what I am trying to do seems to be delegation, but that just produces more code and makes it less readable in my opinion.

I would just like to know a good reason for this. I dont want to think that this has been done haphazardly but rather there were very good arguments for this design of the java language.

But the compiler / JVM is not forced to do it this way.
They could load the class and everything and give you access to everything that is not abstract. This is not magic, this is programming. Whatever we want to do is possible because we make it.

I am not trying to solve any problem with abstract static. As I stated in my initial post, this is a theoretical question. I was just wandering why this was not implemented as it seemed like a very useful feature to me.

For example, imagine you need to know the size in bytes for data types. (maybe to exchange data with another process or maybe to use a native library). It would be nice to have an abstract class like "DataType" which is a super class of Integer, Float, Double, etc. And "DataType" has an abstract static method called "sizeOf()" which returns the size of the type in bytes. The class Integer could implement the method and return 4, the same goes for Float, while Short would return 2 and Double would return 8.
It doesnt make much sense to have this method not static. Its not like every Integer would have a different size. It just feels correct to do it this way, using polymorphism and such.

But that was just a quick example I made up on the spot. Maybe there are much better examples which I just cant think of at the moment.