Recientemente, he notado que hay una opción para tener métodos estáticos en las interfaces. Igual que con los campos estáticos de la interfaz, hay un comportamiento interesante: estos no se heredan.
No estoy seguro de que sea útil en las interfaces reales que se van a implementar. Sin embargo, le permite al programador crear interfaces que solo son envolventes para cosas estáticas, como por ejemplo, Las clases de utilidad son.
Un ejemplo simple es solo un sobre para constantes globales. Comparado con una clase, puede notar fácilmente el texto faltante de public static final como se suponen (haciéndolo menos detallado).
public interface Constants {
String LOG_MESSAGE_FAILURE = "I took an arrow to the knee.";
int DEFAULT_TIMEOUT_MS = 30;
}
También podrías hacer algo más complejo, como este pseudo-enum 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 los servicios públicos, a menudo es útil utilizar métodos de ayuda privados o protegidos, lo que no es posible en las clases.
Considero que es una buena característica nueva, 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 puede considerarlo una buena práctica. Si bien el estilo del código y las mejores prácticas no son axiomáticos y hay espacio para la opinión, creo que generalmente existen razones válidas que respaldan la opinión.
Me interesan más las razones (no) para usar patrones como estos dos.
Tenga en cuenta que no pretendo implementar esas interfaces. Son simplemente un sobre por su contenido estático. Solo pretendo usar las constantes o los métodos y posiblemente usar la importación estática.