Conflictos de nomenclatura de interfaz en Java

Las interfaces en Java consisten en métodos abstractos (que no contienen un cuerpo) y variables (que son finales estáticas públicas). La implementación de los métodos de la interfaz se define en las clases que implementan esa interfaz. Ayuda a Java a lograr la abstracción. 

Los conflictos de nombres ocurren cuando una clase implementa dos interfaces que tienen métodos y variables con el mismo nombre.

Conflictos de nomenclatura de interfaz

Como la interfaz consta de variables y métodos, pueden ocurrir dos tipos de conflictos de nombres.

1. Conflicto de nombres de métodos
2. Conflicto de nombres de variables

1. Conflicto de nombres de métodos

Los conflictos de nomenclatura de este método pueden ocurrir en varios casos. 

Caso-1: cuando tenemos dos interfaces con el mismo nombre de método, la misma firma, el mismo tipo de retorno, la clase de implementación puede implementar cualquiera de ellos, y no podemos decir cuál de estos implementó.

Código

public interface Interface1 {
 
    // create a method
    public void show();
}

public interface Interface2 {
 
    // create a method
    public void show();
}

public class Case1 implements Interface1, Interface2 {
    // implement the methods of interface
    public void show()
    {
        System.out.println("Geeks For Geeks");
    }
    public static void main(String[] args)
    {
        // create object
        Case1 obj = new Case1();
        // using object call the implemented method
        obj.show();
    }
}

Producción 

Geeks For Geeks

Explicación: Aquí, en el siguiente código, no podemos confirmar qué muestra se ejecuta un método de 2 interfaces. No se lanzará ningún error.

Caso 2: cuando dos interfaces consisten en métodos con el mismo nombre pero firmas diferentes, entonces en la clase de implementación, necesitamos implementar tanto los métodos como los métodos que se ejecutan según el tipo de método que llamamos. 

Código 

public interface Interface1 {
 
    // create a method
    public void show();
}

package geeks;
 
public interface Interface2 {
    // define an abstract method with parameters
    public void show(String s);
}

public class Case2 implements Interface1, Interface2 {
    // implement method of Interface2
    @Override public void show(String s)
    {
        System.out.println(s);
    }
    // implement method of Interface1
    @Override public void show()
    {
        System.out.println("Geeks For Geeks");
    }
 
    public static void main(String[] args)
    {
 
        // create object
        Case2 obj = new Case2();
        // calling methods
        obj.show();
        obj.show("GFG");
    }
}

Producción 

Geeks For Geeks
GFG

Explicación: En este caso, la ejecución de estos métodos se puede diferenciar en función de la firma y el tipo de retorno se ignora en este caso.

Caso 3: cuando dos interfaces contienen un método con el mismo nombre, la misma firma pero diferentes tipos de devolución, en este caso, ambas interfaces no se pueden implementar en la misma clase. Es necesario crear clases separadas para implementar cada interfaz de ese tipo.

Código 

public interface Interface1 {
 
    // create a method
    public void show();
}

public interface Interface2 {
    // create method with same name & signature but
    // different return type
    public String show();
}

// implement only 1 interface
public class Case3_1 implements Interface1 {
    // override method of that interface
    @Override public void show()
    {
        System.out.println("Geeks for Geeks");
    }
 
    public static void main(String[] args)
    {
        // create object
        Case3_1 obj = new Case3_1();
        // calling method
        obj.show();
    }
}

Producción 

Geeks for Geeks

Explicación: En este caso, no podemos implementar ambas interfaces en la misma clase porque se puede generar un error debido a la ambigüedad entre ellas. Entonces necesitamos crear una clase diferente para implementar Interface2.

Otros ejemplos: 

// implement only 1 interface
public class Case3_2 implements Interface2 {
    // override the method of interface
    @Override public String show() { return "GFG"; }
 
    public static void main(String[] args)
    {
        // object creation
        Case3_2 obj = new Case3_2();
        // calling method
        String res = obj.show();
        // printing returned result
        System.out.println(res);
    }
}

Producción 

GFG

Si intentamos implementar ambas interfaces en la misma clase, arrojará un error.

Código (Error de lanzamientos)

public class Case3_1_2 implements Interface1, Interface2 {
 
    public void show()
    {
        System.out.println("Geeks for Geeks");
    }
    @Override public String show()
    {
        String s = "GFG" return s;
    }
 
    public static void main(String[] args)
    {
        Case3_1_2 obj = new Case3_1_2();
        obj.show();
    }
}

Producción 

Exception in thread "main" java.lang.Error: Unresolved compilation problems: 
    The return type is incompatible with Interface2.show()
    Duplicate method show() in type Case3_1_2

• Como implementamos métodos que tienen la misma firma y nombres con un tipo de retorno diferente de ambas interfaces en la misma clase, arroja un error.
• Es imposible implementarlos en la misma clase.

Ahora pasaremos a otro tipo de conflictos de nombres de interfaz.

2. Conflicto de nombres de variables

Cuando dos interfaces consisten en la variable con el mismo nombre, entonces la clase que implementa esas interfaces no puede identificar a qué variable acceder y arroja un error. Por lo tanto, para resolver eso, acceda a la variable usando el nombre de la interfaz como referencia.

Código

public interface Interface1 {
    String s = "Geeks for Geeks";
}

public interface Interface2 {
    String s = "GFG";
}

// implement the interfaces
public class VariableConflict
    implements Interface1, Interface2 {
    public static void main(String[] args)
    {
        // create object
        VariableConflict obj = new VariableConflict();
       
        // if we print the data in variable with out
        // specifying reference of interface it throws error
        // System.out.println(s);  error
        System.out.println(Interface1.s);
        System.out.println(Interface2.s);
    }
}

Producción

Geeks for Geeks
GFG

Explicación: aquí, si no usamos la referencia del nombre de la interfaz al acceder a las strings, arroja un error de referencia ambiguo. Por lo tanto, usar el nombre de la interfaz como referencia evita la ambigüedad al acceder.