Java-Schnittstelle: Erben, Überschreiben und Überladen von Methoden

In den folgenden zwei Schnittstellen methodA() ist identisch definiert in Bezug auf die Parameter (keine) und den Rückgabetyp (int). Die Implementierung der Klasse an der Unterseite, definiert eine einzige Methode, mit der genauen Signatur. Denn es entspricht sowohl Schnittstellen, die Sie bekommen, kein problem - alle Anrufe, die über eine Referenz des Typs InterfaceA InterfaceB-Schnittstelle oder versandt werden, um diese Umsetzung.

Zweiten methodB() ist definiert als die Rückgabe eines Subtyps von Number (oder Number selbst) in InterfaceA. InterfaceB definiert methodB() als Rückgabe ein Integer ist ein Subtyp des Number. Die Umsetzung Klasse implementiert die Methode mit Integer, so ist nach dem Vertrag der beiden InterfaceA und InterfaceB. Kein problem, hier entweder.
Der auskommentierten Fall von methodB() umgesetzt als Rückgabe ein Double jedoch nicht funktionieren würde: es wäre Zwar gerecht, der Vertrag von InterfaceA, es würde in Konflikt mit InterfaceB (welche Anforderungen ein Integer).

Wenn InterfaceA und InterfaceB wurden auch die Angabe von (unterschiedlichen) Verträge für eine methodC() (auskommentiert im Beispiel) wäre dies widersprüchlich und erzeugen einen compiler-Fehler. Die Durchführung beider Unterschriften (die sich nur im Rückgabetyp) ist nicht erlaubt, in Java.

Den oben genannten Regeln würde auch zutreffen, wenn waren, um irgendwelche Parameter zu den Methoden. Für Einfachheit, behielt ich diese aus dem Beispiel.

public interface InterfaceA {
    public int methodA();
    public Number methodB();
    //public int methodC(); //conflicting return type
}

public interface InterfaceB {
    public int methodA();
    public Integer methodB();
    //public String methodC(); //conflicting return type
}

public class ImplementationOfAandB implements InterfaceA, InterfaceB {
    public int methodA() {
        return 0;
    }
    public Integer methodB() {
        return null;
    }
    //This would NOT work:
    //public Double methodB() {
    //    return null;
    //}
}

interface A
{
   void foo();
   //int bar(); <-- conflicts with B.bar() because of different return type
}

interface B
{
   void foo();
   //double bar(); <-- conflicts with A.bar() because of different return type
}

class C implements A, B
{
   void foo() //this implements A.foo() AND B.foo()
   {
      ...
   }
}

/**
 * This is what you have
 */
interface IXR {
        //bla-bla-bla
}

class CXR implements IXR {
        //concrete implementation of bla-bla-bla
}

interface IX {
        public IXR f();
} 

interface IYR {
        //some other bla-bla-bla
}

class CYR implements IYR {
        //concrete implementation of the some other bla-bla-bla
} 

interface IY {
        public IYR f();
}






/**
 * This is what you need to add
 */ 
interface IZR extends IXR, IYR {
        //EMPTY INTERFACE
}

class CZXR extends CXR implements IZR {
        //EMPTY CLASS
} 

class CZYR extends CYR implements IZR {
        //EMPTY CLASS
}

class CZ implements IX, IY
{
        public static boolean someCondition = true;

        public IXR implementationOf_X_f()
        {
                System.out.println("CXR");
                return new CZXR();
        }

        public IYR implementationOf_Y_f()
        {
                System.out.println("CYR");
                return new CZYR();
        }

        public IZR f() {
                if (someCondition) {
                        return (IZR) implementationOf_X_f();
                } else {
                        return (IZR) implementationOf_Y_f();
                }
        }

}






/**
 * This is the usage of the required class
 */
class program 
{ 
        public static void main(String[] x) {
                CZ o = new CZ();
                IZR r = o.f();
                if (CZ.someCondition) {
                        CXR xr = (CXR) r;
                        //bla-bla-bla
                } else {
                        CYR yr = (CYR) r;
                        //bla-bla-bla
                }
        }
} /**
 * This is what you have
 */
interface IXR {
        //bla-bla-bla
}

class CXR implements IXR {
        //concrete implementation of bla-bla-bla
}

interface IX {
        public IXR f();
} 

interface IYR {
        //some other bla-bla-bla
}

class CYR implements IYR {
        //concrete implementation of the some other bla-bla-bla
} 

interface IY {
        public IYR f();
}






/**
 * This is what you need to add
 */ 
interface IZR extends IXR, IYR {
        //EMPTY INTERFACE
}

class CZXR extends CXR implements IZR {
        //EMPTY CLASS
} 

class CZYR extends CYR implements IZR {
        //EMPTY CLASS
}

class CZ implements IX, IY
{
        public static boolean someCondition = true;

        public IXR implementationOf_X_f()
        {
                System.out.println("CXR");
                return new CZXR();
        }

        public IYR implementationOf_Y_f()
        {
                System.out.println("CYR");
                return new CZYR();
        }

        public IZR f() {
                if (someCondition) {
                        return (IZR) implementationOf_X_f();
                } else {
                        return (IZR) implementationOf_Y_f();
                }
        }

}






/**
 * This is the usage of the required class
 */
class program 
{ 
        public static void main(String[] x) {
                CZ o = new CZ();
                IZR r = o.f();
                if (CZ.someCondition) {
                        CXR xr = (CXR) r;
                        //bla-bla-bla
                } else {
                        CYR yr = (CYR) r;
                        //bla-bla-bla
                }
        }
}