Recientemente me di cuenta de que hay una opción para tener métodos estáticos en las interfaces. Al igual que con los campos estáticos de interfaz, hay un comportamiento interesante: estos no se heredan.
No estoy seguro de que sea útil en las interfaces reales que se implementarán. Sin embargo, permite al programador crear interfaces que son solo sobres para cosas estáticas, como por ejemplo, las clases de utilidad.
Un ejemplo simple es solo un sobre para constantes globales. En comparación con una clase, puede notar fácilmente la repetitiva faltante, public static finalya que se asume (lo que lo hace menos detallado).
public interface Constants {
String LOG_MESSAGE_FAILURE = "I took an arrow to the knee.";
int DEFAULT_TIMEOUT_MS = 30;
}
También podría hacer algo más complejo, como este pseudoenum de claves de configuración.
public interface ConfigKeys {
static createValues(ConfigKey<?>... values) {
return Collections.unmodifiableSet(new HashSet(Arrays.asList(values)));
}
static ConfigKey<T> key(Class<T> clazz) {
return new ConfigKey<>(clazz);
}
class ConfigKey<T> {
private final Class<T> type;
private ConfigKey(Class<T> type) {
this.type = type;
}
private Class<T> getType() {
return type;
}
}
}
import static ConfigKeys.*;
public interface MyAppConfigKeys {
ConfigKey<Boolean> TEST_MODE = key(Boolean.class);
ConfigKey<String> COMPANY_NAME = key(String.class);
Set<ConfigKey<?>> VALUES = createValues(TEST_MODE, COMPANY_VALUE);
static values() {
return VALUES;
}
}
También podría crear alguna "clase" de utilidad de esta manera. Sin embargo, en las utilidades, a menudo es útil usar métodos auxiliares privados o protegidos, lo cual no es posible en las clases.
Considero que es una nueva característica agradable, y especialmente el hecho de que los miembros estáticos no se heredan es un concepto interesante que se introdujo solo en las interfaces.
Me pregunto si puedes considerarlo una buena práctica. Si bien el estilo de código y las mejores prácticas no son axiomáticas y hay espacio para la opinión, creo que generalmente hay razones válidas para respaldar la opinión.
Estoy más interesado en las razones (no) para usar patrones como estos dos.
Tenga en cuenta que no tengo la intención de implementar esas interfaces. Son simplemente un sobre para su contenido estático. Solo pretendo usar las constantes o métodos y posiblemente usar la importación estática.
defaultmétodos. Estoy hablando de staticmétodos y campos. Esos no son heredados, por lo que no rompen la herencia múltiple.