Static Interface Fields

Question

public interface interface {
     static public field = 1;
     public void methods();
when is this correct to use in the OOP/Software Pattern paradigm?
I thought interfaces were only there to define behaviors (i.e. methods)
What are static fields doing here?
Why are static methods not allowed in interfaces while static fields are?
Thanks

Answer 1

public interface interface {
     static public field = 1;
     public void methods();
}Indded it should be public static final (i.e., constants). The compiler supports not specifying final, and adds it automatically, but one should make that explicit.
when is this correct to use in the OOP/Software
Pattern paradigm?Unlike the previous posters, I don't find that bad against OO principle.
If a constant is logically related to the capabilities defined by an interface, it's not a bad thing in itself to declare the constants in the interface's namespace.
public interface HairDressable {
  public static final int BLONDE = 0;
  public static final int RED = 2;
  public static final int BLACK = 3;
  public void haveHairCut();
  public void haveColorChanged(int newColor);
  public int getHairColor();
}All classes implementing the interface automaticaly see the constant, and can refer to it without prefixing by the interface name. public class PomPomGirl implements HairDressable {
  public void haveColorChanged(int newColor) {
    if (this.favoriteTeam.getName().equals("Red Socks") && (newColor!=RED)) {...}
}Any class not implementing the interface can also refer to the constant, by prefixing with the interface's name, as in public class RedTeamFanClub {
public void makeUp(PomPomGirl pomPomGirl) {
    pomPomGirl.haveColorChanged(HairDressable.RED);
} What IS bad is to have a class implement the interface only for the sake of referring to the variable without prefixing, like public class HairDresser implements HairDressable {
  public void handleFancyLady(Bimbo bimbo) {
    bimbo.changeColor(RED);
  // Dummy implementation of method that should belong here
  public void haveHairCut() {}
  public void haveColorChanged(int  c) {}
  public int getHairColor() {return BLACK;}
I thought interfaces were only there to define
behaviors (i.e. methods) I would say "to advertise capabilities".
Here both changing the color and getting the current color are capabilities that involve a notion of color that is common to all HairDressable implementing classes. I deem defining this notion in the interface itself makes sense.
(OK, defining this notion as a bunch of int constants is not very well engineered, but let's keep the discussion focused).
Now there's the pragmatic approach too : if you define constants in your interface, you run the risk that a bad programmers will someday implement the interface only to lazily refer to the constant.
But you run that risk with abstract classes too - yes, I've seen that!
Why are static methods not allowed in interfaces while
static fields are?Only static final fields, which makes a difference.
Static methods don't advertise the capabilites of an object. And they can't be overridden.
Neither does a constant, in itself, but there's a point in defining the constant in the scope where it makes the most logical sense.
For completeness, note there's an RFE on the BugParade to add statis methods to interfaces (http://developer.java.sun.com/developer/bugParade/bugs/4093687.html).
As I understand it, and although I don't support it, I think there's a point in defining a static method and its implementation in an interface, so as to, in the same vein as for the constants, put in the interface's scope a method whose implementation logically has a meaning for all implementing classes of the interface
(I'd say such methods are rare enough not to deserve a language change).
But it seems ugly (and fortunately impossible at that point) to add the notion of "abstract static methods" that an interface could declare and all implementing class would have to implement.