Kann man Variablen oder Felder definieren deren Typ zwei Interfaces ist..?

[sirbender]

Kann man eine lokale Variable oder Feld oder statische Variable definieren deren Typ von 2 Interfaces (Schwimmen und Rennen) bestimmt wird? Dadurch koennte ich dann Objekte zuweisen, die diese beiden Interfaces implementieren (z.B. Objekte vom Typ Mensch und Hund)...wobei Mensch und Hund beide andere Superklassen haben. Die Interfaces implementieren aber beide.

 

[httpdigest]

Nein, das geht leider nicht. Solche "Intersection Types" sind nur für Upper Bounds bei Typvariablen möglich, z.B.:

interface Schwimmen {}
interface Rennen {}
public static <T extends Schwimmen & Rennen> void methode(T t) {
  ...
}

oder:

class SomeClass<T extends Schwimmen & Rennen> {
  private T t;
  ...
}

 

[mihe7]

z.B. Objekte vom Typ Mensch und Hund

Ist das dann der Mund oder der Hensch?

 

[Meniskusschaden]

Ist das dann der Mund oder der Hensch?

Das ist natürlich der Möter: halb Mensch, halb Köter: https://de.wikipedia.org/wiki/Mel_Brooks’_Spaceballs

 

[mihe7]

Das ist natürlich der Möter:

Mist, ich vergaß...

 

[kneitzel]

Mist, ich vergaß...

Ja, da sind hier doch wenig Experten hier im Forum unterwegs ... (Ups, sind doch nicht in der Plauderecke) 🙂 Aber einzelne reißen es dann doch immer wieder raus ...

Aber zurück zum Thema:
Wieso eine Variable die beide Interfaces haben soll?
Kannst Du den Usecase etwas aufzeigen? Ist das evtl. nicht einfach zwei Variablen?
Oder wenn es so etwas spezielles ist: Dann ist es evtl. ein neues Interface, welches die beiden anderen implementiert?

Das Szenario würde mich sehr interessieren, denn dann könnte man diesbezüglich mehr über mögliche Designs sagen.

 

[sirbender]

Waere toll wenn man wenigstens eine Liste definieren koennte, die Objekte von Typen aufnehmen kann die zwei bestimmte Interfaces implementieren.

TypA und TypB sind grundverschieden. Gemeinsam haben Sie zwei Interfaces die beide implementieren. Ich bin eigentlich nur an der Funktionalitaet interessiert, die diese beiden Interfaces bereitstellen. Leider kann ich Objekte von TypA und TypB nicht in die gleiche Liste stecken ohne dann umstaendlich beim Rausholen aus der Liste instanceof checks und Casts um die Funktionalitaet beider Interfaces verwenden zu koennen.
Im Moment ist meine die Liste mit einem der Interfaces parametrisiert und ich muss jedesmal Casten wenn ich auch auf das andere Interface zugreifen will. Schlimmer noch, diese Loesung sorgt dann dafuer, dass ich versehentlich Objekte in die Liste stecken koennte die nur das Interface der Liste implementieren was dann beim Casten zum Fehler fuehrt.

Nun koennte ich zwei getrennte Listen machen mit List<TypA> und List<TypB>. Aber das ist dann insgesamt auch sehr umstaendlich spaeter.

TypA und TypB und deren Vererbungshierarchie hab ich uebrigens nicht selbst geschrieben 😉

 

[tommysenf]

Du könntest dir zum Beispiel einen Wrapper bauen welcher die Intersection Types nutzt:

import java.util.ArrayList;
import java.util.List;

public class InterfaceTest {

    static interface Rennen {
        void run();
    }
    
    static interface Schwimmen {
        void swim();
    }
    
    static class Hund implements Rennen, Schwimmen {
        @Override
        public void swim() {}
        @Override
        public void run() {}
    };
    static class Mensch implements Rennen, Schwimmen {
        @Override
        public void swim() {}
        @Override
        public void run() {}
    };
    
    
    static class MoeterWrapper<T extends Schwimmen & Rennen> implements Rennen, Schwimmen {
        
        private T moeter;

        MoeterWrapper(T moeter) {
            this.moeter = moeter;
        }
        
        @Override
        public void swim() {
            moeter.swim();
        }

        @Override
        public void run() {
            moeter.run();
        }
    }
    
    public static void main(String[] args) {
        
        List<MoeterWrapper<?>> list = new ArrayList<>();
        list.add(new MoeterWrapper<>(new Mensch()));
        list.add(new MoeterWrapper<>(new Hund()));
        for (MoeterWrapper<?> moeter : list) {
            moeter.swim();
        }
    }
    
}

 

[krgewb]

public class Hauptprogramm {
    public static void main(String[] args) {
        Hensch h = new Hensch();
        h.aufZweiBeinenLaufen();
        h.bellen();
    }
}

public class Hensch extends Mensch implements Hund {
    @Override
    public void bellen() {
        System.out.println("Wuff!");
    }
}

public interface Hund {
    public void bellen();
}

public class Mensch {
    public void aufZweiBeinenLaufen() {
        System.out.println("Ich laufe auf zwei Beinen.");
    }
}

Ausgabe:
Ich laufe auf zwei Beinen.
Wuff!

 

[sirbender]

Hehe...sehr lustig 😉

Ich finde es jedenfalls ein Manko, dass man Methoden definieren kann, die z.B. <T extends ISchwimmen & IRennen> T zurueckgeben kann...aber keine Liste mit den selben Interfaces erzeugen kann, die dann diese Rueckgabewerte aufnimmt.