Miré a un cierto código y se dio cuenta dicha construcción:
public interface TestIntrerface {
void doFirst();
void doSecond();
}
public interface Interface1 extends TestIntrerface {
Interface1 inter = new FirstClass();
}
public interface Interface2 extends TestIntrerface {
Interface2 intr = new SecondClass();
}
public class FirstClass implements Interface1 {
public void doFirst() {
//...
}
public void doSecond() {
//...
}
}
public class SecondClass implements Interface2 {
public void doFirst() {
//...
}
public void doSecond() {
//...
}
}
public class Test {
public static void main(String[] args) {
Interface1.inter.doFirst();
Interface2.intr.doSecond();
}
}
Tiene el potencial para mí, pero nunca he visto que antes de constructo. Dos preguntas:
- ¿Cuál es el nombre de este patrón (es que el patrón (?))?
- Es una práctica buena para utilizar esto en el mundo real?
Es un ejemplo de dos declaraciones de constantes inter
y intr
en las interfaces. No es un patrón y yo no diría que es una buena práctica.
Interface1
yInterface2
no tienen sentido: que no se complementan / implementan las interfaces que se extienden. Básicamente, son los titulares de las constantes que podrían haber sido definidos en otro lugar. Tenga en cuenta que las constantes están obligados a clases particulares mientras que las interfaces llevan un sentido más amplio, proporcionan una interfaz general.Los nombres
inter
yintr
son terribles y que no dicen lo que representan esas constantes / do.
Un ejemplo más justificable que parezca
interface TestInterface {
void doFirst();
void doSecond();
TestInterface EMPTY = new TestInterface() {
@Override
public void doFirst() {}
@Override
public void doSecond() {}
};
}
donde EMPTY
dice que se trata de un defecto (y vacío) implementación de la interfaz. Tenga en cuenta que he llamado EMPTY
(no empty
) porque siempre es un public static final
campo.