Final arguments in interface methods — what’s the point?
In Java, it is perfectly legal to define final arguments in interface methods and do not obey that in the implementing class, e.g.:
public interface Foo < public void foo(int bar, final int baz); >public class FooImpl implements Foo < @Override public void foo(final int bar, int baz) < . >> In the above example, bar and baz has the opposite final definitions in the class VS the interface. In the same fashion, no final restrictions are enforced when one class method extends another, either abstract or not. While final has some practical value inside the class method body, is there any point specifying final for interface method parameters?
Just as a point of discussion: I just tried it and if two interface definitions vary only in the final attribute of an argument, then the resulting .class files are byte-for-byte identically (and of course javap -v produces the same output). The same is true for two classes that only differ in final on an attribute, by the way!
@Paul: it does exactly the same thing as with reference types: it prevents the arguments itself to be modified (if used in the implementation).
@Deepak: I see you asking for working examples on all kinds of questions, even when it doesn’t seem to make a lot of sense. I think you should try learning some abstract thinking: try thinking about a problem without having some executable code in front of you. It will help you a lot in the long run.
5 Answers 5
It doesn’t seem like there’s any point to it. According to the Java Language Specification 4.12.4:
Declaring a variable final can serve as useful documentation that its value will not change and can help avoid programming errors.
However, a final modifier on a method parameter is not mentioned in the rules for matching signatures of overridden methods, and it has no effect on the caller, only within the body of an implementation. Also, as noted by Robin in a comment, the final modifier on a method parameter has no effect on the generated byte code. (This is not true for other uses of final .)
Does method parameter also qualify as a variable? It obviously is in practice, but is it in specification context?
It can’t be used to match signatures since it is does not appear in the actual .class file. It is for the compiler only.
@mindas — the JLS says that there are seven kinds of variables. Method paramaters are fourth on the list.
Documentation is next to useless, however, since the final modifier is not enforced on the implementing class. Your interface signature may simply lie.
The Java 8 language spec now says that there are eight kinds of variables (up from seven—they added lambda parameters). Method parameters are still fourth on the list (at least some things in life seem stable. :-)).
Some IDEs will copy the signature of the abstract/interface method when inserting an implementing method in a sub class.
I don’t believe it makes any difference to the compiler.
EDIT: While I believe this was true in the past, I don’t think current IDEs do this any more.
Valid point, although I don’t think there were many IDEs when this feature was implemented (or left accidentally) 🙂
Final annotations of method parameters are always only relevant to the method implementation never to the caller. Therefore, there is no real reason to use them in interface method signatures. Unless you want to follow the same consistent coding standard, which requires final method parameters, in all method signatures. Then it is nice to be able to do so.
Update: Original answer below was written without fully understanding the question, and therefore does not directly address the question 🙂 Nevertheless, it must be informative for those looking to understand the general use of final keyword.
As for the question, I would like to quote my own comment from below.
I believe you’re not forced to implement the finality of an argument to leave you free to decide whether it should be final or not in your own implementation.
But yes, it sounds rather odd that you can declare it final in the interface, but have it non-final in the implementation. It would have made more sense if either:
a. final keyword was not allowed for interface (abstract) method arguments (but you can use it in implementation), or
b. declaring an argument as final in interface would force it to be declared final in implementation (but not forced for non-finals).
I can think of two reasons why a method signature can have final parameters: Beans and Objects (Actually, they are both the same reason, but slightly different contexts.)
public static void main(String[] args) < StringBuilder cookingPot = new StringBuilder("Water "); addVegetables(cookingPot); addChicken(cookingPot); System.out.println(cookingPot.toString()); // ^--- OUTPUT IS: Water Carrot Broccoli Chicken ChickenBroth // We forgot to add cauliflower. It went into the wrong pot. >private static void addVegetables(StringBuilder cookingPot) < cookingPot.append("Carrot "); cookingPot.append("Broccoli "); cookingPot = new StringBuilder(cookingPot.toString()); // ^--- Assignment allowed. cookingPot.append("Cauliflower "); >private static void addChicken(final StringBuilder cookingPot) < cookingPot.append("Chicken "); //cookingPot = new StringBuilder(cookingPot.toString()); // ^---- COMPILATION ERROR! It is final. cookingPot.append("ChickenBroth "); >The final keyword ensured that we will not accidentally create a new local cooking pot by showing a compilation error when we attempted to do so. This ensured the chicken broth is added to our original cooking pot which the addChicken method got. Compare this to addVegetables where we lost the cauliflower because it added that to a new local cooking pot instead of the original pot it got.
Beans: It is the same concept as objects (as shown above). Beans are essentially Object s in Java. However, beans (JavaBeans) are used in various applications as a convenient way to store and pass around a defined collection of related data. Just as the addVegetables could mess up the cooking process by creating a new cooking pot StringBuilder and throwing it away with the cauliflower, it could also do the same with a cooking pot JavaBean.
Why are all fields in an interface implicitly static and final?
I am just trying to understand why all fields defined in an Interface are implicitly static and final . The idea of keeping fields static makes sense to me as you can’t have objects of an interface but why they are final (implicitly)? Any one knows why Java designers went with making the fields in an interface static and final ?
For a note for myself: It’s static because the fields of interface won’t become a part of the object which implements it.
7 Answers 7
An interface is intended to specify an interaction contract, not implementation details. A developer should be able to use an implementation just by looking at the interface, and not have to look inside the class which implements it.
An interface does not allow you to create an instance of it, because you cannot specify constructors. So it cannot have instance state, although interface fields can define constants, which are implicitly static and final.
You cannot specify method bodies or initializer blocks in an interface, although since Java 8 you can specify default methods with bodies. This feature is intended to allow new methods to be added to existing interfaces without having to update all the implementations. But you still cannot execute such a method, without first creating an instance implementing the interface.
Aside: Note that you can implement an interface with an anonymous inner class:
interface Foo < String bar(); >class FooBar < Foo anonymous = new Foo() < public String bar() < return "The Laundromat Café"; >; > You have to provide the full implementation of the interface for the anonymous inner class to compile.
new Foo() is initializing the anonymous inner class with its default constructor.